diff --git a/2024/06/26/chenge-first-blog/index.html b/2024/06/26/chenge-first-blog/index.html index c7bf4f1..d366705 100644 --- a/2024/06/26/chenge-first-blog/index.html +++ b/2024/06/26/chenge-first-blog/index.html @@ -289,12 +289,16 @@

- 3 + 6 日志
-
+
1 + 分类 +
+
+ 2 标签
diff --git a/2024/06/26/hello-world/index.html b/2024/06/26/hello-world/index.html index 0aebcc5..e3c1754 100644 --- a/2024/06/26/hello-world/index.html +++ b/2024/06/26/hello-world/index.html @@ -309,12 +309,16 @@

- 3 + 6 日志

-
+
1 + 分类 +
+
+ 2 标签
diff --git a/2024/06/28/InterProScan/index.html b/2024/06/28/InterProScan/index.html index b540595..3118e38 100644 --- a/2024/06/28/InterProScan/index.html +++ b/2024/06/28/InterProScan/index.html @@ -236,7 +236,10 @@

TBtoo

-
+
+
@@ -309,12 +312,16 @@

TBtoo
- 3 + 6 日志
-
+
1 + 分类 +
+
+ 2 标签
diff --git "a/2024/07/02/Python\345\205\245\351\227\250\345\237\272\347\241\200\350\257\276/index.html" "b/2024/07/02/Python\345\205\245\351\227\250\345\237\272\347\241\200\350\257\276/index.html" new file mode 100644 index 0000000..e062ce3 --- /dev/null +++ "b/2024/07/02/Python\345\205\245\351\227\250\345\237\272\347\241\200\350\257\276/index.html" @@ -0,0 +1,1077 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Python入门基础课 | Bio_Learning + + + + + + + + + + + + +
+
+ +
+
+
+
+ + + +
+
+ +
+ + + +

Bio_Learning

+ + +

yang51的学习笔记

+
+ +
+
+
+
+
+ + + + + + + + + +
+
+ + +
+ + 0% +
+ + +
+
+
+ + +
+ + + + + +
+ + + + + +
+

+ Python入门基础课 +

+ +
+ + + + + 发表于 + + + + + + + + + 分类于 + + + + + + + +
+
+ + + + +
+ + + + + + + + + + + + + + + +
imageimageimage
问答社区网站（电脑使用）：http://www.omicsclass.com/组学大讲堂问答小程序(手机使用)组学大讲堂公众号
+
+

Python基础语法学习

语法

    +

  • 注释：

    +

    使用 #表示注释行,一般井号在行首，也可以在行的中间，那么#后面的为注释信息

    +

    带有 #号的行python解释器会忽略

    +
    • +

  • 缩进

    +

    使用缩进表示层次关系，或者区分不同的代码块，不像perl语言用{}

    +

    约定使用4个空格缩进

    +
    • +

  • 续行

    +

    在行尾使用 \

    +

    如果使用各种括号，认为括号内是一个整体，括号内部跨行不用 \

    +
    • +
+

Python示例代码：

+
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
32
33
34
35
36
37
38
39
40
41
42
'''
Description: This script is used to onvert U in fasta sequence file to T
Date: 2019
Auther: omicsgene
'''

from Bio.Seq import Seq
from Bio import SeqIO
from Bio.Alphabet import IUPAC
from Bio.SeqRecord import SeqRecord
import sys, os, argparse, os.path,re,math,time
#参数设置
parser = argparse.ArgumentParser(description='This script is \
    used to onvert U in fasta sequence file to T')
parser.add_argument('-f','--fasta',help='Please fasta file',required=True)
parser.add_argument('-o','--out_dir',help='Please input complete out_put directory path',
                    default = os.getcwd(),
                    required=False)

parser.add_argument('-n','--name',default ='demo_seq',required=False,
                    help='Please specify the output, demo_seq')
################################################################################
#读入参数，初始化路径
args = parser.parse_args()
dout=''
if os.path.exists(args.out_dir):
    dout=os.path.abspath(args.out_dir)
else:
    os.mkdir(args.out_dir)
    dout=os.path.abspath(args.out_dir)

output_handle = open(dout+'/'+args.name+'.fa', "w")
#循环处理序列将U转换成T,然后输出
for rec in SeqIO.parse(args.fasta, "fasta"):
    seq=rec.seq
    seq=str(seq.upper())
    seq=seq.replace("U", "T")
    seq_r = SeqRecord(Seq(seq,alphabet = IUPAC.IUPACAmbiguousDNA()), 
                      id=rec.id,
                      description=rec.description)
    SeqIO.write(seq_r, output_handle, "fasta")
output_handle.close()
+ + + + +

Python 标准数据类型和变量

数字：

    +
  • 整数 integer： 11，223，-23
    • +
  • 布尔值 bool ：True False
    • +
  • 浮点数 float： 1.2 、 1.46 、 1.44e10 、 -1.6e-66
    • +
  • 复数： 1+2j
    • +
+

字符串 string：

    +
  • 使用 ‘ “ 单引号或者双引号引用的字符
    • +
  • ‘’’ 和 “”” 可以跨行，可以在其中任意的使用单双引号
    • +
+

空值

1
None
+ + +

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

+

变量：

变量：

+

和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。

+

变量名：

+
    +
  1. 必须是大小写英文字母、数字和 _ 的组合，且不能用数字开头。例如，可将变量命名为message_1，但不能将其命名为1_message。
    2. +
  2. 变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greeting message会引发错误。
    3. +
  3. 不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print。
    4. +
  4. 变量名应既简短又具有描述性，让人一看就知道里面代表的是什么数据。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。
    5. +
  5. 慎用小写字母l和大写字母O，因给他们可能被人错看成数字1和0；
    6. +
+
1
2
3
4
a = 123 # a是整数
print(a)
a = 'ABC' # a变为字符串
print(a)
+ +

变量的理解

1
2
3
4
a = 'abc'
b = a
a = 'xyz'
print(b)
+ +

1： 执行a = ‘abc’，解释器创建了字符串’abc’和变量a，并把a指向’abc’：

+
1
2
graph LR
a-->abc
+

2：执行b = a，解释器创建了变量b，并把b指向a指向的字符串’abc’：

+
1
2
3
graph LR
a-->abc
b-->abc
+ +

3：执行a = ‘xyz’，解释器创建了字符串’xyz’，并把a的指向改为’xyz’，但b并没有更改：

+
1
2
3
graph LR
a-->xyz
b-->abc
+ + +

Python 标准数据的操作

数字操作运算

    +
  • 加减乘除 + - * /
    • +
  • 求余运算 % 求幂运算 **
    • +
  • 自然除/ 结果是浮点数，整除//。注意：在2.x中/和//都是整除。
    • +
+

注意：字符串可以相加和相乘

+

字符串中特殊字符的转义：\

    +
  • 例如要在字符串中输入一个换行符： 
    1
    "hello python\n"
    • +
  • 其他常见特殊意义的转义：
    1
    \\  \t  \r  \n  \'  \"
    • +
  • 字符前缀 r
    • +
+
1
print(r'my name is \n \"lucy\"')
+ + + +

练习：
打印以下变量

+
1
2
3
4
5
6
7
x = 122223
y = 45116e-789
a1 = 'Hello, world'
a2 = 'Hello, \'Lily\''
a3 = r'Hello, "Mike"'
a4 = r'''Hello,
omicsclass!'''
+ +

字符串格式化输出

    +
  • %运算符格式化字符串
    • +
  • %s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。
    • +
+
1
2
3
4
print('Age: %s. Gender: %s' % (25, True))
print('growth rate: %d %%' % 7)
print('%2d-%02d' % (3, 1))
print('%.2f' % 3.1415926)
+ + + +

关于字符串操作的一些方法

==重点掌握：split，strip，join==

+

方法的调用用 . 操作符

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法说明
strip、rstrip、lstrip去除空白符。相当于对各个元素执行x.strip()
split通过指定的分隔符将字符串拆分为一组子串
join将字符串用作连接其他字符串序列的分隔符
count返回子串在字符串中出现次数
endswith、startswith如果字符串以某个后缀结尾（或开头），则返回True
lower、upper分别将字母字符转换为小写或大写
replace用另一个字符串替换指定子串
ljust、rjust用空格(或其他字符)填充字符串的空白侧以返回符合最低宽度的字符串
index如果在字符串中找到子串，则返回子串第一个字符所在的位置。如果没有找到，则引发ValueError
find如果在字符串中找到子串，则返回第一个发现的子串第一个字符所在的位置。如果没有找到，则返回-1
rfind如果在字符串中找到子串，则返回最后一个发现的子串的第一个字符所在的位置。如果没有找到，则返回-1
+

示例代码：

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

s = 'A,T,C,G,A\n'
print(s)
print(s,end="")
print(s.strip())

s = 'A,T,C,G,A'
s.split(',')

"\t".join(["A","T","T"])


s = 'A,T,C,G,A'
s.replace('A','T')
s.count(',')
s.index('c')
s.find('c')
s.endwith("A")
s.lower()

#函数
len(s)


+ +

注意: 调用函数或者方法，一定要跟()

+

==小知识==
Python中函数和方法的区别：

+

在Python中，函数(function) 和方法(method) 是有区别的：

+
    +

  • 所处的位置不同：函数是直接写在文件中而不是class中，方法是只能写在class中。

    +
    • +

  • 调用的方式不同：函数可以直接调用，例如：len() print()等等，方法是在类中，一般用. 来调用，如： 前面学习的：lst.index()

    +
    • +
+

python中的列表list和元组tuple

介绍

list 列表

+
    +
  • list是一种有序的集合，可以随时添加和删除其中的元素。
    • +
  • 元素的类型可以是任意对象(数字，字符串，逻辑值，列表，对象等等)
    • +
  • 使用[]表示列表
    • +
+

tuple 元组

+
    +
  • tuple：另一种有序列表,tuple和list非常类似，但是tuple一旦初始化就不能修改。
    • +
  • 使用()表示元组
    • +
+

list的创建与初始化：

+
1
2
3
mylst=[]
mylst=[1,3,"a","xy",[11,22]]

+ +

tuple的创建：

+
1
2
classmates = ('Michael', 'Bob', 'Tracy')
t = ('a', 'b', ['A', 'B'])
+ + + +

列表list相关的操作&函数&方法

列表的查询：

支持索引用中括号：[]
    +
  • 正索引：从左到右，从0开始
    • +
  • 负索引：从右往左，从-1开始
    • +
+
1
2
3
4
5
6
lst=["A","T","A","a",22,[333,444]]

lst[1]
lst[0]
lst[-1]

+ +
列表切片
1
2
3
4
5
6
7
8
lst=["A","T","A","a",22,[333,444]]
lst[0:3]
#表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
#如果第一个索引是0，还可以省略：
lst[:3]

lst[-2:-1]
lst[-2:]
+
注意多维[][]
1
2
lst=["A","T","A","a",22,[333,444]]
lst[5][0]
+ +

列表元素修改

1
2
3
4
5
lst=["A","T","A","a",22,[333,444]]
lst[5][0]=333

lst[0]="omicsclass"

+ + +

列表相关方法:

重点掌握方法：==append extend sort==

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法功能
list.append(x)在列表末尾添加新的对象
list.sort(key=None, reverse=False)对原列表进行排序
list.extend(iterable)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.count(x)统计某个元素在列表中出现的次数
list.index(x[, start[, end]])从列表中找出某个值第一个匹配项的索引位置
list.insert(i, x)将对象插入列表
list.pop([i])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(x)移除列表中某个值的第一个匹配项
list.reverse()反向列表中元素
+

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
lst=["A","T","A","a",22,[333,444]]
#列表结尾追加元素
lst.append("omicsgene") 

#将可迭代的对象元素追加进来；
lst.extend(["omicsgene","omicsclass"]) 

#在指定的索引处插入元素
lst.insert(1,"omicsclass") 

#从左到右查询第一个匹配的元素删除
lst.remove("A")  

#不指定索引，就从列表结尾删除元素，并返回该元素
#也可以指定索引弹出；
lst.pop()
lst.pop(2)

#反转list，会修改原列表

lst.reverse()
+ +

列表相关的函数

+ + + + + + + + + + + + + + + + + + + + + + +
函数功能
len(list)列表元素个数
list(iterable)将可迭代对象转换为列表
max(list)返回列表元素最大值
min(list)返回列表元素最小值
+
1
2
3
4
5
6
7
8
a=[11,44,5,55,33,31,62,42]
len(a)
max(a)
min(b)

list([11,44,5,55,33,31,62,42])
list(range(10))

+ +

列表的排序

有全局函数sorted，和列表自带方法sort

+

list.sort(key=None, reverse=False)

+
    +
  • key 指定带有一个参数的函数或者方法，用于从每个列表元素中提取比较键(例如key=str.lower)。对应于列表中每一项的键会被计算一次，然后在整个排序过程中使用。默认值None表示直接对列表项排序而不计算一个单独的键值。
    • +
  • reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
    • +
+
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
## 1、最简单的排序
l = [5,2,3,1,4 ]
l.sort()
print(l)   

#反序
l.sort(reverse=True)
print(l)    

##2、字符串排序
StrList = ['Fast', 'Smooth', 'fast', 'isb', 'isa', 'smooth']
#一般字典序排列，但是大写在前，小写在后！！
StrList.sort()
print(StrList) 

##2.2忽略大小写，按abcd顺序
StrList.sort(key=str.lower)
print(StrList) 

##2.3按照字符串长度排序
StrList.sort(key=len)
print(StrList)

#一起使用两个参数
StrList.sort(key=len, reverse=True)
print(StrList)
+ + +

sorted(iterable, key=None, reverse=False)

+
    +
  • iterable – 可迭代对象。 例如：列表 range对象 字符串等
    • +
  • key – 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。
    • +
  • reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
    • +
+
1
2
3
4
5
6
7
8
9
a = [5,7,6,3,4,1,2]
b = sorted(a)       # 保留原列表
print(b)
b = sorted(a,reverse=True)  
print(b)
a = ['Fast', 'Smooth', 'fast', 'isb', 'isa', 'smooth']
b = sorted(a,key=str.lower,reverse=False)  
print(b)

+ +

sort 与 sorted 区别：

+
    +

  • 调用方式不同：
    sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

    +
    • +

  • 返回对象不同：
    list 的 sort 方法是在原来的列表上操作，无返回值（None），而函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

    +
    • +
+

python中的字典dict和集合set

    +
  • dict 字典
    • +
+

dict全称dictionary，使用键-值（key-value）存储，具有极快的查找速度。类似perl里面的hash。

+

字典的创建

字典的每个键值 key=>value对 用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

+
1
dict = {'a': 1, 'b': 2, 'b': '3'}
+

字典的特性：

    +
  1. 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行(列表是可变类型)：
    2. +
  2. 值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的。
    3. +
+
1
2
3
4
d = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'} 

#会报错
d = {['Name']: 'Zara', 'Age': 7}
+ +

修改字典

向字典中 添加新内容的方法是增加新的键/值对，修改或删除已有键/值对:

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
d = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
d['Name']                        #取值
d['Age'] = 18                    # 更新
d['School'] = "omicsclass"       # 添加
 
#取值打印
print( "d['Age']: ", d['Age'])
print("d['School']: ", d['School'])


# 删除字典元素


d = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
del d['Name']  # 删除键是'Name'的条目
d.clear()      # 清空字典所有条目
del d          # 删除字典
 
print("d['Age']: ", d['Age'])
print("d['School']: ", d['School'])
+ +

字典内置方法

+ + + + + + + + + + + + + + + + + + + + + + +
方法描述
dict.keys()以列表返回一个字典所有的键
dict.values()以列表返回字典中的所有值
dict.items()以列表返回可遍历的(键, 值) 元组数组
dict.get(key, default=None)返回指定键的值，如果值不在字典中返回default值
+

判断字典key是否存在

+
1
2
3
4
5
6
7
8
9
10


#使用格式：
#key in dict
#key not in dict

d = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
'Name' in d
'Name' not in d

+ + +

集合

    +
  • set 集合
    • +
+

set 集合是一个无序的不重复元素序列。是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

+
    +
  • 集合创建
    • +
+

可以使用大括号 { } 或者 set() 函数创建集合。

+

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

+

集合的创建与运算

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
genes = {'gene1', 'gene1', 'gene2', 'gene3', 'gene4', 'gene5'}

genes = set(['gene1', 'gene1', 'gene2', 'gene3', 'gene4', 'gene5'])

print(genes)   


#集合运算与判断
'gene1' in genes 

'gene11' in genes

#字符有列表特性，所以可以直接set   
a = set('omicsgene')
b = set('omicsclass')

# 集合a中包含而集合b中不包含的元素
a - b                              
# 集合a或b中包含的所有元素
a | b                              
# 集合a和b中都包含了的元素
a & b                              
# 不同时包含于a和b的元素
a ^ b

+ + +

集合常用操作方法

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
方法描述
set.add(x)参数作为一个元素添加到原set集合
set.update(s)可以添加多个元素，且参数可以是列表，元组，字典等
set.remove(x)依据值删除，不存在会抛出异常KeyError
set.discard(x)依据值删除，不存在不会报错
set.clear()清空原set
+

代码示例：

+
1
2
3
4
5
6
7
8
9
10
11
12
13
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
basket.add(("aa","dd"))
basket.update("dcc")
print(basket)


basket.remove("apple")
basket.remove("apple1")
basket.discard("apple1")

basket.clear()


+ + +

数据类型及类型转换

Python3 支持 的标准数据类型总结

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
类型类名
Number（数字）int、float、bool、complex（复数）
String（字符串）str
List（列表）list
Tuple（元组）tuple
Set（集合）set
Dictionary（字典）dict
+

Python3 的六个标准数据类型中：

+
    +
  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
    • +
  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
    • +
+
1
2
3
4
5
6
7
8
9
10
11
#批量赋值
a, b, c, d ,e= 20, 5.5, "ATGC", True, 4+3j

#获得数据类型
print(type(a), type(b), type(c), type(d), type(e))

#判断数据类型
a=1
isinstance(a, int)


+ + +

类型转换函数：

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
函数描述
int(x [,base])将x转换为一个整数
float(x)将x转换到一个浮点数
str(x)将对象 x 转换为字符串
list(s)将序列 s 转换为一个列表
set(s)转换为可变集合
tuple(s)将序列 s 转换为一个元组
dict(d)创建一个字典。d 必须是一个 (key, value)元组序列。
complex(real [,imag])创建一个复数
repr(x)将对象 x 转换为表达式字符串
eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象
frozenset(s)转换为不可变集合
chr(x)将一个整数转换为一个字符
ord(x)将一个字符转换为它的整数值
hex(x)将一个整数转换为一个十六进制字符串
oct(x)将一个整数转换为一个八进制字符串
+

python中语句(if、for、while)

if 语句 做判断

计算机之所以能做很多自动化的任务，因为它可以自己做条件判断。

+

python中常见比较判断运算符

==、 != 、 < 、> 、 >= 、 <=、in、not in

+

注意：in、not in ： 判断值是否存在列表中或者字典的键中

+
示例代码：
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#简单的判断
age = 20
if age >= 18:
    print('your age is', age)
    print('adult')

l=['Fast', 'Smooth', 'fast', 'isb', 'isa', 'smooth']
s = {'gene1', 'gene1', 'gene2', 'gene3', 'gene4', 'gene5'}
d = {'gene1':122, 'gene2':2212, 'gene3':3121, 'gene4':2323, 'gene5':2543}


if 'Fast' not in l:
    print(True)

#else 语句
    
age = 3
if age >= 18:
    print('your age is', age)
    print('adult')
else:
    print('your age is', age)
    print('teenager')


#elif语句    
age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')


#判断条件依次执行，有一个为真就跳出
age = 66
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
elif age >= 60:
    print('old people')
else:
    print('kid')
+ +

逻辑运算符 增加判断条件

    +
  • 与 、或 、非 ： and 、 or 、 not
    • +
+
    +
  1. and 如果第一个表达式为False，后面没有必要计算
    2. +
  2. or 如果第一个表达式是True，后面就没有必要计算了
    3. +
  3. 条件很多不知道判断优先顺序可以添加小括号
    4. +
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#逻辑运算符
age=11
gender="male"

if age>=18 and age<=60 and gender=="female":
    print("adult woman")

if age<18 or age >60 and gender=="female":
    print("kid or old woman")  
    
if age>=18 and age<=60 and not gender=="female":
    print("adult man")


+ +

特殊数据真值表

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
对象/变量值
“”假
“string”真
0假
() 空元组假
[] 空列表假
{} 空字典假
None假
+

for 循环语句

计算机之所以能批量的执行数据分析，就是因为有循环语句。

+

for…in循环，in 后面跟可迭代对象

+
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#列表遍历
names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)
    
    
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)    


#产生连续的数字函数：range(start, stop[, step])

range(10)
range(2,10)
#也可以转换成list对象
list(range(10))
list(range(1, 11))
list(range(0, 30, 5))
list(range(0, 10, 3))
list(range(0, -10, -1))
list(range(0))
list(range(1, 0))


sum = 0
for x in range(101):
    sum = sum + x
print(sum)


sum = 0
for x in range(3,101):
    sum = sum + x
print(sum)


sum = 0
for x in range(3,101,2):
    sum = sum + x
print(sum)


#enumerate函数  同时获取索引还有值

#用法enumerate(sequence, [start=0])

names = ['Michael', 'Bob', 'Tracy']
for index,value in enumerate(names):
    print(index,value)


#字典遍历
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
for k,v in dict.items():
    print(k,v)

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
for k in dict.keys():
    print(k,dict[k])
+ +

while 循环语句

while循环，只要条件满足，就不断循环，条件不满足时退出循环

+
1
2
3
4
5
6
sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)
+ +

循环控制语句

break 提前退出循环
continue 提前结束本轮循环

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
n = 1
while n <= 100:
    if n > 10: # 当n = 11时，条件满足，执行break语句
        break # break语句会结束当前循环
    print(n)
    n = n + 1
print('END')


n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数，执行continue语句
        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)
+ + +

==练习题==

+
    +
  1. for 循环打印星号金字塔：
    2. +
+
1
2
3
4
5
    *
   ***
  *****
 *******
*********
+ +

答案：

+
1
2
3
4
5
6
7
for i in range(1, 6):
     for j in range(0, 6 - i):
         print (" ",end="")
     
     print( "*"*(i),end="")
     print( "*"*(i-1),end="")       
     print("")
+ +
    +
  1. 利用for循环，打印乘法口诀：
    2. +
+
1
2
3
4
5
6
7
8
9
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81
+ +

答案：

+
1
2
3
4
for m in range(1, 10):
    for n in range(1, m+1):
        print("%d*%d=%d\t"%(n,m,n*m), end="")
    print("")
+ + +

python 读写数据文件

python文件读写分为三步

    +
  1. 打开文件获取文件对象
    2. +
  2. 操作文件
    3. +
  3. 关闭文件
    4. +
+
1
2
3
fr = open("test.txt","r")      #打开文件
ff = fr.read()                 #读取文件所有内容  （不建议使用，如果文件内容巨大，内存会爆）
print(ff)
+ +

文件类型

+ + + + + + + + + + + + + + + + + + +
参数描述
r只读，默认模式 打开数据文件
w只写，不可读，若文件不存在则创建，若存在，则删除内容，写入新内容
a只追加，不可读，若文件不存在则创建，存在则追加新内容
+

文件方法（不常用）

前三个方法：在大文件时慎用，会把内容读到内存中，占用大内存

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法描述
f.write()字符串写入一个打开的文件
f.close()刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
f.read()#读取所有内容
f.readline()#读取一行
f.readlines()#读取所有文件内容，返回一个list
f.seek(0)#当前文件指针位置在0位
f.writelines([“a”,”b”])#把列表写入文件
+

文件的读入与写出（常用方法）：

文件的读入与写出主要用的是for循环：

+
1
2
3
4
5
6
7
fr=open("input.fa","r")   #输入文件，读取数据
fw=open("output.fa","w")   #输出文件，写出结果
for line in fr:              #循环一行一行的读取文件                                 
    new_line = line.replace("A","T")                         
    fw.write(new_line)
fr.close()  #关闭文件
fw.close()  #关闭文件
+ + +

测试文件内容：
input.fa

+
1
2
3
4
5
6
7
8
9
10
11
AGTTAGCGGATAATGGCCATCAAAGCAACGCTTACCAACACTGCACCCCTTGTTTTGGAAATGCAACCAC
AAAAGCATTGGACACTTGCTTACTTCAAATAAAACACATTTAAACAATTAGATGACGTGATGGACCAGAA
TGGCGCATCGGGAAGTCATCCGAACAGGCTATCCCAAGGAAGAGGAGCCCATGCGCGCGAACGTGGCGCC
ACAGTTTCCGCGGCGGCAAATCGGAGTAACATTATCGACGAAATGGCCAAAATATGCGAAGCCGATCGCC
AGACTTTCGCCATCGCTCGACGGACTCGGGGTCACGAGCGGCTTGCGGTGGACAACAGCGACTTCGTCGC
CGTGGAGGATCTTATTTTGTCCTACGCAGAGCCCACGCCCGAGGACCAGGTCGAGATGATCATGAGCGAC
TTTTGCTCGTCTCCAACATACGCAGAGGATGAGGATGAGCCCAGCCATGAGTCGGAGCCGTGGTTTCGAT
TTCGCAACAAAAGGATCAGAACCTACAGCCGGAAGAGGGATCCCAAAAGCCACAAGGCCGTTCAAAACGA
GAAGCGTAGAGGTTCCTCAGGCCTCTCCGTGCAGAGGGATCTCAATACTTCGTTCACATCTATGGCTTGT
GATTTCGATGCTTCATCACAGAAGATACACGAGGTCCTTTTGAACCTCAGTCAATACTTTTCCGCGACCG
CGACAGCTTCCGGTCCGACTCCTGTCCCATCGCAAATAGATCTGCCAACCGAAGCAAGGCAGGATT
+ +
+

==学习任务==

+
    +
  • 编写脚本要求：
    • +
  • 读取gff文件，筛选出文件中1号染色体100000-500000之间的基因
    • +
  • 输出基因的名字，染色体，起始位置，终止位置信息用tab分隔各列
    • +
+

输入文件下载地址：

+

ftp://ftp.ensemblgenomes.org/pub/plants/release-44/gff3/arabidopsis_thaliana/Arabidopsis_thaliana.TAIR10.44.chromosome.1.gff3.gz

+

注意：几乎所有的生物数据文件都是文本文件，都可以用notepad++，editplus等文本编辑器打开，不要被文件后缀名迷惑，我们的编程语言python绝大多数情况下打开处理的也都是文本文件。

+
+

答案：

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
fr=open("D:\python_script\Arabidopsis_thaliana.TAIR10.44.chromosome.1.gff3\Arabidopsis_thaliana.TAIR10.44.chromosome.1.gff3","r")
fw=open("D:\python_script\Arabidopsis_thaliana.TAIR10.44.chromosome.1.gff3\out.txt","w")

for line in fr:
    line=line.strip()
    if not line[0]=="#":
        tmp=line.split("\t")
        if tmp[0]=="1" and tmp[2]=="gene" and int(tmp[3])>100000 and int(tmp[3])<500000:
            geneID=tmp[8].split(";")[0].split("=")[1]
            #mystr=tmp[0]+"\t"+tmp[3]+"\t"+tmp[4]+"\t"+geneID+"\n"
            mystr="\t".join([tmp[0],tmp[3],tmp[4],geneID])+"\n"
            fw.write(mystr)
            #fw.write(line+"\n")
    
fr.close()
fw.close()
+
+ + + + + + + +
+ + + + + + +
+ + + + +
+ + +
+ + + +
+ + + + + +
+
+ +
+
+ + + + +
+ + © + 2024 + + + + yangzy +
+ + + + + + + + + + + + +
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/2024/07/02/Python\347\273\230\345\233\276matplotlib/index.html" "b/2024/07/02/Python\347\273\230\345\233\276matplotlib/index.html" new file mode 100644 index 0000000..01b5def --- /dev/null +++ "b/2024/07/02/Python\347\273\230\345\233\276matplotlib/index.html" @@ -0,0 +1,458 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Python 绘图matplotlib包科学绘图 | Bio_Learning + + + + + + + + + + + + +
+
+ +
+
+
+
+ + + +
+
+ +
+ + + +

Bio_Learning

+ + +

yang51的学习笔记

+
+ +
+
+
+
+
+ + + + + + + + + +
+
+ + +
+ + 0% +
+ + +
+
+
+ + +
+ + + + + +
+ + + + + +
+

+ Python 绘图matplotlib包科学绘图 +

+ +
+ + + + + 发表于 + + + + + + + + + 分类于 + + + + + + + +
+
+ + + + +
+ + +

Python 绘图matplotlib包科学绘图

Matplotlib:

+

Python中最著名的绘图系统，pandas绘图也是由其封装而成。

+

官方网站：https://matplotlib.org/

+

1 认识matplotlib绘图包绘图要素以及对应的类（对象）

    +
  • Figure
    • +
+

The whole figure. The figure keeps track of all the child Axes, a smattering of ‘special’ artists (titles, figure legends, etc), and the canvas。

+

The top level container Artist is the matplotlib.figure.Figure

+
    +
  • Axes
    • +
+

This is what you think of as ‘a plot’, it is the region of the image with the data space. A given figure can contain many Axes, but a given Axes object can only be in one Figure.

+
    +
  • Axis
    • +
+

These are the number-line-like objects. They take care of setting the graph limits and generating the ticks (the marks on the axis) and ticklabels (strings labeling the ticks).

+
    +
  • Artist
    • +
+

Basically everything you can see on the figure is an artist (even the Figure, Axes, and Axis objects). This includes Text objects, Line2D objects, collection objects, Patch objects … (you get the idea).

+

要素之间的关系：

image

+

多张图，要素之间的关系：

image

+

Figure中更详细对象总结

image

+

2 matplotlib包安装

安装说明：
https://matplotlib.org/users/installing.html#installing-an-official-release

+
1
2
3
4
5
6
pip install matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple

#jupyter 支持绘图显示，命令行需要安装运行以下代码：

pip install ipympl  -i https://pypi.tuna.tsinghua.edu.cn/simple
jupyter nbextension enable --py --sys-prefix ipympl
+ + + +

3 matplotlib绘图基础

matplotlib.pyplot 绘图入口模块

==matplotlib.pyplot 模块中有很多函数，我们直接调用就可以绘图：==

+

Everything in matplotlib is organized in a hierarchy. At the top of the hierarchy is the matplotlib “state-machine environment” which is provided by the matplotlib.pyplot module.

+

我们使用matplotlib.pyplot 里面的函数来创建绘图，绘图主要有以下三步：

+
    +
  • 第一步：创建Figure对象，相当于画布
    • +
  • 第二步：画布中添加Axes对象，画布中可以有很多图（Axes）
    • +
  • 第三步：利用Axes对象的方法绘图（plot，bar，pie等等）
    • +
+

示例代码：

+
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#########################################
#载入包，模块等等
#########################################
import matplotlib.pyplot as plt
import numpy as np

###########################
##第一步和第二步：  获得，Figure对象和Axes对象
###########################

#方法1：
fig = plt.figure(figsize=(8, 6))
ax1 = fig.add_axes([0.1, 0.1, 0.35, 0.8])
ax2 = fig.add_axes([0.55, 0.1, 0.35, 0.8])

#或者
ax1 = fig.add_subplot(211)
ax2 = fig.add_subplot(212)


#方法2：
fig, ax = plt.subplots(figsize=(8, 6))
#或者 
fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2,figsize=(8, 6))

##########################
##第三步： 绘图
#############################

x = np.linspace(0, 2, 100)   
fig, ax = plt.subplots(figsize=(8, 6))



ax.plot(x, x, label='linear')
ax.plot(x, x**2, label='quadratic')
ax.plot(x, x**3, label='cubic')
ax.set_xlabel('x label')
ax.set_ylabel('y label')
ax.set_title("Simple Plot")
ax.legend()

plt.show()

#保存图片
#plt.savefig("D:\\python_script\\test.pdf")
#plt.savefig("D:\\python_script\\test.png",dpi=300)
+ + +

面向对象绘图和面向过程的绘图

推荐面向对象的绘图，思路会更加清晰。

+
1
2
3
4
5
6
7
8
9
10
11
12
13
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2, 100)
plt.plot(x, x, label='linear')
plt.plot(x, x**2, label='quadratic')
plt.plot(x, x**3, label='cubic')
plt.xlabel('x label')
plt.ylabel('y label')
plt.title("Simple Plot")
plt.legend()
plt.show()

+

3 学会自学绘图

方法模板的API：每个类、方法、函数，参数的详细说明

https://matplotlib.org/api/index.html#modules

+

使用说明

https://matplotlib.org/users/index.html

+

利用例子学习绘图

https://matplotlib.org/gallery/index.html

+ +
+ + + + + + + +
+ + + + + + +
+ + + + +
+ + +
+ + + +
+ + + + + +
+
+ +
+
+ + + + +
+ + © + 2024 + + + + yangzy +
+ + + + + + + + + + + + +
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/2024/07/02/Python\351\253\230\347\272\247\347\274\226\347\250\213/index.html" "b/2024/07/02/Python\351\253\230\347\272\247\347\274\226\347\250\213/index.html" new file mode 100644 index 0000000..802a3f5 --- /dev/null +++ "b/2024/07/02/Python\351\253\230\347\272\247\347\274\226\347\250\213/index.html" @@ -0,0 +1,1708 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Python 高级编程 | Bio_Learning + + + + + + + + + + + + +
+
+ +
+
+
+
+ + + +
+
+ +
+ + + +

Bio_Learning

+ + +

yang51的学习笔记

+
+ +
+
+
+
+
+ + + + + + + + + +
+
+ + +
+ + 0% +
+ + +
+
+
+ + +
+ + + + + +
+ + + + + +
+

+ Python 高级编程 +

+ +
+ + + + + 发表于 + + + + + + + + + 分类于 + + + + + + + +
+
+ + + + +
+ + + + + + + + + + + + + + + +
imageimageimage
问答社区网站（电脑使用）：http://www.omicsclass.com/组学大讲堂问答小程序(手机使用)组学大讲堂公众号
+
+

Python高级编程

1 函数

1.1 Python内置函数：

Python内置了很多有用的函数，我们可以直接调用。

+

内置函数总结：https://docs.Python.org/zh-cn/3.7/library/functions.html

+
1
2
3
4
5
abs(-100)
max(1, 2)
int('123')
float('12.34')
sum([2,323,23])
+ +

1.2 Python 用户自定义函数

自定义函数：把具有独立功能的代码块组织成为一个小模块。

+

好处：

+
    +
  1. 代码复用，提高编程效率，使程序易于理解。
    2. +
  2. 自己学会定义函数，有助于理解看懂别人函数的帮助
    3. +
+

定义一个函数

你可以定义一个自定义功能的函数，以下是简单的规则：

+
    +
  1. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
    2. +
  2. 括号里面可设置参数，参数不是必必需的(可有可无)，传入参数必须放在圆括号中间。
    3. +
  3. 函数的第一行语句可以选择性地（可有可无）使用文档字符串—用于存放函数使用说明。
    4. +
  4. 函数内容以冒号起始，并且缩进。
    5. +
  5. return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
    6. +
+

参数作用：增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据

+
    +
  1. 在函数内部，把参数当作变量使用，进行需要的数据处理
    2. +
  2. 函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递
    3. +
+

示例

1
2
3
4
5
6
7
8
9
10
11
12
13

#定义
def hello(s):
    '''this function is used to say hello,
    and exit.
    
    '''
    print('hello '+s)
    return
    
#调用
hello(s="omicsgene")

+ + +

不同类型参数的设置与使用

参数根据位置传递

如果我们设置了多个参数，python解释器会根据位置进行传递；

+
1
2
3
4
5
6
7
8
9
10
11
12

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

power(2,3)

power(x=2,n=3)

+ + +
必需参数

直接设定参数，没有给参数的默认值，函数调用时必需给参数传入值

+
1
2
3
4
5
6
7
8
9

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
    
power(4)
+ + + +
设置默认参数(函数调用时可有可无)

设置参数是可以设定参数的默认值，函数调用时可选给参数传入值们不给就是默认值。

+
1
2
3
4
5
6
7
8
9
10
11
12
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

def info(name, gender, age=6, city='Beijing'):
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)
+ + +
可变参数位置参数

* 在参数名字前面加一个星号，使参数成为一个可变参数，参数传入一个列表

+
1
2
3
4
5
6
7
8
def add(a,b):
    return a+b

def add1(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n 
    return sum
+ +
可变关键字参数

** 在参数名字前面加两个星号，使参数成为一个可变关键字参数，参数传入一个字典

+
1
2
3
4
5
6
7
def person(name, age, **kwargs):
    print('name:', name, 'age:', age, 'other:', kwargs)


#联合使用，参数如何传递？  
def foo(a,b,c=22,*args,**kwargs):
    print("a:",a,",","b:",b,",","c:",c,",","args:",args,",","kwargs:",kwargs)
+ +
强制 key=value形式传递

有个参数只有一个星号,表示星号后面的参数必须用（key=value）的形式进行传递参数，不能省略key。

+
1
2
3
4
5
6
7
8
def foo1(a,b,*,c=3):
    print(a,b,c)
    
def foo2(a,b,c=3):
    print(a,b,c)

foo1(1,2,4)
foo2(1,2,4)
+ + +
函数编写与调用注意事项
    +
  1. 必需参数一般写在前面，有默认值的参数紧随其后（位置参数）
    2. +
  2. 参数名省略时，注意位置
    3. +
+
1
2
3
4
def foo(a,b,c=22,*args,**kwargs):
    print(a,b,c,args,kwargs)

foo()
+ + + +

1.3 Python中匿名函数

有时候一个函数只是临时使用一下，以后就不会再使用了，要是用def定义比较麻烦。这个时候就可以用lambda来定义一个匿名函数

+
语法：

变量名= lambda [arg1[, arg2, … argN]]: expression

+
注意:
    +
  1. 参数：可选，通常以逗号分隔的变量表达式形式，也就是位置参数
    2. +
  2. 表达式中不能包含 循环，return
    3. +
  3. 可以包含 if…else…语句.
    4. +
  4. 表达式计算的结果直接返回
    5. +
+
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

# 使用lambda的表达式
lambda x, y: x + y

# 使用def定义的函数
def add( x, y ):
  return x + y

# lambda也允许有默认值和使用变长参数
lambda x, y = 2: x + y
lambda *z: z

# 调用lambda函数
a = lambda x, y: x + y
a(1, 3)

b = lambda x, y = 2: x + y
b(1)

b(1, 3)

c = lambda *z: z
c(10, 'test')


+ + + +

匿名函数应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#自定义排序关键字

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2])            # 按年龄排序
sorted(students, key=lambda s: s[2], reverse=True)       # 按降序


#字典排序：


dic = {'a':2,'b':1}
#按照key排序
d = sorted(dic.items(), key = lambda k:k[0])

#按照values排序
 e = sorted(dic.items(), key = lambda k:k[1])


+

1.4 变量作用域

变量的作用域决定了在哪一部分程序你可以访问那个特定的变量名称。一个程序的所有的变量并不是在任何位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

+

两种最基本的变量作用域如下：

+
    +
  • 全局变量
    • +
  • 局部变量
    • +
+
全局变量和局部变量
    +

  • 定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

    +
    • +

  • 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

    +
    • +
+
1
2
3
4
5
6
7
8
9
10
total = 0; # 这是一个全局变量

def mysum( arg1, arg2 ):
   total = arg1 + arg2; # total在这里是局部变量.
   print("inside  ", total)
   return total
 
#调用mysum函数
mysum( 10, 20 )
print("global var ", total)
+ + +

1.5 变量传递给参数参数的可变性

函数的参数传递中传入可变数据和不可变数据会有不同：

+
    +
  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
    • +
  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
    • +
+
传不可变对象实例,传进去的变量不改变原变量
1
2
3
4
5
6
def ChangeInt(a):
    a = 10
 
b = 2
ChangeInt(b)
print (b) # 结果是 2
+ +
传可变对象实例,传进去的变量可改变原变量
1
2
3
4
5
6
7
8
9
10
def changeme(mylist):
   "修改传入的列表"
   mylist.append([1,2,3,4]);
   print("Inside value:", mylist)
   return
 
# 调用changeme函数
mynum = [10,20,30]
changeme(mynum)
print("Outside value:", mynum)
+ +
+

2 面向对象的编程与获取帮助

2.1 类和实例

+

面向对象最重要的概念就是类（Class）和实例（Instance），类描述了一组具有相同特性（属性）和相同行为（方法）的对象(Object)。面向对象的编程语言最大的特色就是可以编写自己所需的数据类型，以更好的解决问题。

+
+
+

必须牢记类是抽象的模板，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法或者属性，但各自的数据可能不同。

+
+

image

+

面向对象编程特点

面向对象编程(Object-oriented programming，缩写：OOP)的3个基本特征是：封装、继承、多态

+
    +

  • 封装：将属性和方法(数据和功能)封装在一起形成类。

    +
    • +

  • 继承：可以使用现有类的功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

    +
    • +

  • 多态：允许让父类的指针分别指向不同的子类, 调用不同子类的同一个方法, 会有不同的执行效果

    +
    • +
+

2.2 面向对象编程

定义一个类

类的组成
    +
  • 属性(对象的属性) ——变量：状态、静态的
    • +
  • 方法(对象的行为) ——函数：过程、动态的
    • +
+
类的方法与属性
+

在类的内部，使用 def 关键字来定义一个方法，类的方法与普通的函数只有一个特别的区别——他们的第一个参数必须是 self。

+
+
+

self代表类的实例，而非类。

+
+
构造方法

类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用。

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#类的定义
class Car:
    '''this class define a car '''
    #类属性  共有属性
    wheels=4
    #构造方法
    def __init__(self, make, model, year):
        #成员属性
        self.make = make
        self.model = model
        self.year = year
        self.orometer_reading = 0
    #类方法
    def get_description(self):
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model+" "+str(self.wheels)
        return long_name
 
    def get_odometer(self):
        print("This car has "+ str(self.orometer_reading) + " miles on it")
 
    def increase(self,miles):
        self.orometer_reading +=miles

+ +

创建类的实例化对象，访问属性和使用方法

现在让我们新建一个对象my_car:

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#类实例my_car
my_car = Car("yellow", "beetle", 1967)
#查看属性
print(f" My {my_car.color} car {my_car.model} is made in {my_car.year}")

#属性修改
my_car.color="black"

#对象方法调用

my_car.get_description()
my_car.increase(1000)
my_car.read_odometer()
my_car.update_orometer(20000)

#查看类或者实例所有的属性与方法
dir(my_car)
dir(Car)
+

2.3 Python 类定义中的特殊属性与方法

Python中用下划线作为变量前缀和后缀指定特殊变量

+
    +
  • _xxx 不能用’from module import *’导入
    • +
  • __xxx 类中的私有变量名
    • +
  • __xxx__ 系统定义的名字
    • +
  • 核心风格：避免用下划线作为变量名的开始。
    • +
+

因为下划线对解释器有特殊的意义，而且是内建标识符所使用的符号，我们建议程序员避免用下划线作为变量名的开始。

+

==一般来讲，变量名_xxx被看作是“私有的”，在模块或类外不可以使用。==

+

当变量是私有的时候，用_xxx 来表示变量是很好的习惯。因为变量名__xxx__对Python 来说有特殊含义，对于普通的变量应当避免这种命名风格。

+
    +
  • “单下划线” 开始的成员变量叫做保护变量，意思是只有类对象和子类对象自己能访问到这些变量；
    • +
  • “双下划线” 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。
    • +
+
Python类的特殊属性
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
属性含义
__class__对象或类所属的类
__name__类、函数、方法等的名字
__dict__类的属性 以key-value形式展示的字典，展示出属性所对应的值
__module__类定义所在的模块名称
__doc__类、函数的文档字符串，如果没有定义则为None
+
1
2
3
4
5
6
7
8
9
10
11
12
#print(my_car.__name__)
print(my_car.__doc__)
print(my_car.__dict__)
print(my_car.__module__)
print(my_car.__class__)


print(Car.__name__)
print(Car.__doc__)
print(Car.__dict__)
print(Car.__module__)
print(Car.__class__)
+ + + +
Python类特殊方法
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法功能说明
__new__()类的静态方法，用于确定是否创建对象
__init__()构造函数，生成对象时调用
__dir__返回类或者对象的所有方法与属性，dir()操作实例就是调用
__del__()析构函数，释放对象时调用
__add__()+
__sub__()-
__mul__()*
__truediv__()/
__floordiv__()//
__mod__()%
__pow__()**
__repr__()打印,转换
__setitem__()按照索引赋值
__getitem__()按照索引获取值
__len__()计算长度
__call__()函数调用
__contains__()in
__eq__()==
__ne__()!=
__lt__()<
__le__()<==
__gt__()>
__ge__()>=
__str__()转换为字符串
__shift__(), __rshift__()<<, >>
__and__(), __or__()&,
__invert__(), __xor__()~, ^
__iadd__(), __isub__()+=, -=
+
例子：实现特殊方法__repr__：
1
2
3
4
5
6
7
8
9
10
11
12
13

## __repr__
class Person:
    def __init__(self, name):
        self.name = name
    def __repr__(self):
        return "hello %s." % self.name

 p = Person('hkey')

 p
 print(p)

+ +

定义了__repr__方法，不管是直接打印对象还是通过print打印对象，都是走的__repr__中定义的格式。

+

更多类的特殊方法了解：https://www.omicsclass.com/article/1033

+

2.4 类的继承 (选修)

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
#类定义
class people:
    #定义属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    #定义类方法
    def speak(self):
        print("%s speak: I am %d years old." %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s speak: I am %d years old， I am in %d grade of primary school."%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()
+

2.5 Python获取帮助

Python 官方中文帮助

https://docs.Python.org/zh-cn/3.7/

+

编辑器提供帮助

pycharm中的documentation内置显示（默认快捷键为Ctrl+Q），选中函数，Ctrl+Q如下：

+

也有External documetation，快捷键为Shift+F1

+

陌生类获取类的属性和方法

dir()函数主要用来查看对象的属性和方法，再去了解这些属性和方法，学习类的使用。

+

__doc__属性查看帮助文档

任务答案

+
1
2
a = [1,2,3]
a.reverse.__doc__
+ + +

==任务答案：==

+
1
2
3
4
5
6
7
8
9
def my_abs(x):
    a=0
    if x>=0:
        a=x
    else:
        a=0-x
    return a
    
my_abs(-100)
+ + +
+

3 Python 标准库中包的使用

python标准库帮助地址：https://docs.python.org/zh-cn/3.7/library/index.html

+

3.1 包常见导入方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 1 直接导入
import os
import time
import sys
import os,time,sys,re  #每个包之间用逗号隔开；

#导入的同时改名字
import sys as system


#2 导入指定的方法，模块等

#导入包里面的指定的函数或者类
from os import path
from os import path, walk, unlinkfrom

#导入包里面所有的内容
from os import *

+ +

这些导入的包，其实就是别人写好的代码文件(*.py)，我们导入到我们的程序中就可以直接使用里面的方法，函数，类等，省去自己编写代码的麻烦。如果了解Python包导入的机制，自己也可以写一些包，共享给别人，提供代码的复用性，从而提高我们的开发效率。

+

3.2 Python 自定义模块导入讲解

模块搜索路径

导入过程首先需要定位导入文件的位置，也就是，告诉Python到何处去找到要导入的文件，因此，需要设置模块的搜索路径。在大多数情况下，Python会自动到默认的目录下去搜索模块；如果要在默认的目录之外导入模块，就需要知道Pyhon搜索模块路径的机制。

+

Python搜索模块的路径是由四部分构成的：==程序的主目录、PATHONPATH目录、标准链接库目录和.pth文件的目录，这四部分的路径都存储在sys.path 列表中。==

+
1， 程序的主目录

主目录是指程序所在的目录，Python首先会到主目录中搜索模块。

+

因为主目录总是第一个被搜索，如果模块完全处于主目录中，所有的导入都会自动完成，而不需要单独配置路径。

+
2，PATHONPATH目录

PythonPATH目录是指PythonPATH环境变量中配置的目录，是第二个被搜索的目录，Python会从左到右搜索PythonPATH环境变量中设置的所有目录。

+
3，标准链接库目录

标准链接库目录是Python按照标准模块的目录，是在安装Python时自动创建的目录，通常不需要添加到PythonPATH目录中。例如：

+
4，路径文件（.pth文件）

在模块搜索目录中，创建路径文件，后缀名为.pth，该文件每一行都是一个有效的目录。Python会读取路径文件中的内容，每行都作为一个有效的目录，加载到模块搜索路径列表中。简而言之，当路径文件存放到搜索路径中时，其作用和PYT)HONPATH环境变量的作用相同。

+

3.3 导入自定义模块指定路径的方法

方法1：简单不用操作

把自己写的模块，复制到自己的程序同级目录就可以直接导入；

+
方法2: 函数添加 （临时添加）
    +
  1. import sys
    2. +
  2. 查看sys.path
    3. +
  3. 添加sys.path.append(“D:\\perl_script”)
    4. +
+
方法3: 增加.pth文件，推荐！ （永久添加）
    +

  • 在site-packages目录添加一个文件如mypkpath.pth，必须以.pth为后缀，文件内写上你要加入的模块文件所在的路径，可以添加多行。

    +
    • +

  • 如果运行在Windows和Python3.0中，如果Python安装目录的顶层是C:\Users\Administrator\AppData\Local\Programs\Python\Python37，那么可以把自定义的路径文件 mypath.pth 放到该目录中。

    +
    • +

  • 也可以放到标准库所在位置的site-packages子目录中（C:\Users\Administrator\AppData\Local\Programs\Python\Python37\Lib\site-packages），来扩展模块的搜搜路径。

    +
    • +
+
方法4: 修改环境变量 （永久添加）
    +
  • windows用户可以修改系统环境变量 PYTHONPATH
    • +
  • linux用户也可以添加环境变量 PYTHONPATH
    • +
+

练习：

导入自己写的一个模块：

+

把以下内容存储到文件cars.py中，然后用import导入该模块：

+
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

CAR_num=11

make=["Ford","Rolls-royce","Volkswagen"]

def mysum( arg1, arg2 ):
   total = arg1 + arg2; # total在这里是局部变量.
   print("inside  ", total)
   return total;


def das_auto(make="Volkswagen", model="Magotan", year=2019):
    '''this function is used to create Volkswagen car'''
    my_car=Car("Volkswagen","Magotan",2019)
    return my_car


#类的定义
class Car:
    '''this class define a car '''
    #类属性  共有属性
    wheels=4
    #构造方法
    def __init__(self, make, model, year):
        #成员属性
        self.make = make
        self.model = model
        self.year = year
        self.orometer_reading = 0
    #类方法
    def get_description(self):
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model+" "+str(self.wheels)
        return long_name
 
    def read_odometer(self):
        print("This car has "+ str(self.orometer_reading) + " miles on it")
 
    def update_orometer(self,miles):
        if miles >= self.orometer_reading:
            self.orometer_reading = miles
        else:
            print("You can'troll back an odometer")
 
    def increase(self,miles):
        self.orometer_reading +=miles

+ +
==小知识== 模块和包的区别

（1）模块：是一个单独的.py文件，用于存放一些功能相关的代码，可以是代码更加容易维护，提高代码的重用价值

+

（2）包：是一个有层级的目录结构，包含n个模块或者n个子包，包中一定要有__init__.py文件

+

3.4 Python中 os sys time math包的学习

os 常用方法

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法说明
os.getcwd()得到当前工作目录，即当前Python脚本工作的目录路径。
os.mkdir()方法用于以数字权限模式创建目录，
os.listdir(path)返回指定目录下的所有文件和目录名。
os.walk()方法用于通过在目录树中游走输出在目录中的文件名，向上或者向下。
os.remove(path)方法用来删除一个文件。如果指定的路径是一个目录，将抛出OSError，在Unix, Windows中有效
os.rmdir(path)方法用于删除指定路径的目录。仅当这文件夹是空的才可以, 否则, 抛出OSError。
os.system(command)函数用来运行shell命令。
os.linesep字符串给出当前平台使用的行终止符。例如，Windows使用’\r\n’，Linux使用’\n’而Mac使用’\r’。
os.sep可以取代操作系统特定的路径分隔符。windows下为 “\\”,linux 下为”/“
os.chdir(dirname)改变工作目录到dirname
os.path.isfile(path)方法分别检验给出的路径是否一个文件，输入路径必须是绝对路径。
os.path.isdir(path)方法检验给出的路径是否一个目录，输入路径必须绝对路径。
os.path.exists()方法用来检验给出的路径是否真地存在
os.path.join(path,name)连接目录与文件名或目录;使用“\”连接
os.path.basename(path)返回文件名
os.path.dirname(path)返回文件路径
os.path.abspath(name)获得绝对路径
os.path.getsize(name)获得文件大小
os.path.split(path)将path分割成目录和文件名二元组返回。
os.path.splitext()分离文件名与扩展名
+

包使用示例代码

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
#遍历一个目录，获得所有文件的路径

import os  
os.chdir("D:\Python_script")
cwd = os.getcwd()  
for dir_path, dir_names, file_names in os.walk(cwd): 
    for file_name in file_names:    
        p=os.path.join(dir_path,file_name)
        print(p)
    for dir_name in dir_names:
        p=os.path.join(dir_path,dir_name)
        print(p)


#windows系统中调用命令
os.system('copy a.v b.v')
os.system('del b.v')
os.system('rename a.v b.v')


#linux系统中调用命令
os.system('cp a.v b.v')
os.system('rm b.v')
os.system('mv a.v b.v')

+ + +

sys包常用属性或者方法

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法说明
sys.argv命令行参数List，第一个元素是程序本身路径
sys.exit(n)退出程序，正常退出时exit(0)
sys.version获取Python解释程序的版本信息
sys.modules返回系统导入的模块字段，key是模块名，value是模块
sys.path返回模块的搜索路径，初始化时使用PythonPATH环境变量的值
sys.stdout标准输出
sys.stdin标准输入
sys.stderr错误输出
+

math 常用属性和方法

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法说明示例
math.e自然常数e>>> math.e
math.pi圆周率pi>>> math.pi
math.log10(x)返回x的以10为底的对数>>> math.log10(2)
math.pow(x, y)返回x的y次方>>> math.pow(5,3)
math.sqrt(x)返回x的平方根>>> math.sqrt(3)
math.ceil(x)返回不小于x的整数>>> math.ceil(5.2)
math.floor(x)返回不大于x的整数>>> math.floor(5.8)
math.fabs(x)返回x的绝对值>>> math.fabs(-5)
+
+

练习：
将文件打开然后，批量的合并到一个文件中

+
1
2
3
4
5
6
7
8
fw=open("all.fa","w")
for i in os.listdir(os.getcwd()):
    if i.endswith("fa"):
        f=open(i,"r")
        for line in f:
            fw.write(line)
        f.close()
fw.close()
+ + +

4 正则表达式：

4.1 了解正则表达式

正则表达式是用于处理字符串（String）的强大工具，拥有自己独特的语法以及一个独立的处理引擎，效率上可能不如str自带的方法，但功能十分强大。得益于这一点，在提供了正则表达式的语言里，正则表达式的语法都是一样的，区别只在于不同的编程语言实现支持的语法数量不同；

+

正则表达式功能

    +
  • 查找/匹配
    • +
  • 替换
    • +
  • 捕获
    • +
  • 计数
    • +
+

正则表达式通配符

    +
  • 通配符是特殊字符，在正则表达式中有特殊意义
    • +
  • 直接的单词或者数字是原样匹配
    • +
+

常见通配符学习

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
模式匹配通配符描述
^匹配字符串的开头
$匹配字符串的末尾。
.匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[…]用来表示一组字符,单独列出：[amk] 匹配 ‘a’，’m’或’k’，[a-zA-Z0-9]
[^…]不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
\w匹配字母数字及下划线
\W匹配非字母数字及下划线
\s匹配任意空白字符，等价于 [\t\n\r\f].
\S匹配任意非空字符
\d匹配任意数字，等价于 [0-9].
\D匹配任意非数字
*匹配0个或多个的表达式,如:be*: b, be,beeeee, bee。
+匹配1个或多个的表达式,如: be+ : be,beeeee, bee。
?匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式 .如 bo? 只能匹配：b,bo
{ n}精确匹配 n 个前面表达式。例如， o{2} 不能匹配 “Bob” 中的 “o”，但是能匹配 “food” 中的两个 o。
{ n,}匹配 n 个前面表达式。例如， o{2,} 不能匹配”Bob”中的”o”，但能匹配 “foooood”中的所有 o。”o{1,}” 等价于 “o+”。”o{0,}” 则等价于 “o*”。
{ n, m}匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
|或者的意思，如：a| b 匹配a或b
()对正则表达式分组并记住匹配的文本,正则表达式捕获功能
+
选修内容
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
模式匹配通配符描述
(?imx)正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)类似 (…), 但是不表示一个组
(?imx: re)在括号中使用i, m, 或 x 可选标志
(?-imx: re)在括号中不使用i, m, 或 x 可选标志
(?#…)注释.
(?= re)前向肯定界定符。如果所含正则表达式，以 … 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)匹配的独立模式，省去回溯。
\A匹配字符串开始
\Z匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z匹配字符串结束
\G匹配最后匹配完成的位置。
\b匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配”never” 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。
\B匹配非单词边界。’er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。
\n, \t, 等.匹配一个换行符。匹配一个制表符。等
\1…\9匹配第n个分组的内容。
\10匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。
+

4.2 正则表达式实操学习

https://regexone.com/

+

正则表达式练习

    +
  • 应用 notepad++ 或者editplus 软件 正则表达式处理文本
    • +
  • 不足之处->无法处理大文件（内存限制）
    • +
+
练习要求：
    +
  • 处理要求1：把序列转换成一行；
    • +
  • 处理要求2：把一行的序列文件再转换回来；
    • +
+

处理文件内容示例：

+
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
32
33
34
35
36
37
>NP_651973.4 nbs, isoform E [Drosophila melanogaster]
MFVLTKDDEKFVLFPGKKVYTIGRLATDLIVAQDLSISRNHAQLLIQTEADGDDTLHIEDLGSRYGTFIF
PKNSQKPRKVPAKTSTPLPVGTRLRFGANMSIWQVTQLKLVTTVSALTRSEVQELTKMLEPMGGTVTSNW
TEECSHLTMNEVSVTVKLLHAMLENKPIVTFPYWRKMLQAAQSIHVKEGWPQPEDYQPTNIDVTWRPERT
RLFAGKTFVFMNRKHFDMYGSVVQKAGATCKDINSGVRKTFLTKSDVIVIQYVPSSQSQATESINSIQDR
YILEQNGRRIIQEYEIGMALIHCSITEFCNPTHKFISDSLPTTESVTSSMAFNSSIIVPNTERHSAQSNA
TPISELVVPESIECEMEQDASKPHSEDQASLRKRSHASTVDSSDEEKKSTLSKRAKSDIATKLTMKSKNA
ILLDSSLEEDVTPAPAPAPVQRVTRQSKAIAEEKSVHPPVPAASKHITRKTKQVFCVDSSDEENENARKP
KETPAPTIPSMAKKKTEAPVATRISPRLNGKSLATNITNQPADKHAVPAKRPVLSVASSDEEDEGDLFQF
RKSPQKPAETVVQPRIAGKGNAPARISVVDFLEKSQAQEPAPVPPQLESQSQTQPRKRLRLELLNESDSD
DCDNLFNFADSKKKRKTQEAQRNDDSTDGLFNFNSERPSDHDDEDSRLTEPFVPETESKKQSKYIVAPRR
DRPKKVDISGWLSCSRLNDNIKSEIDADSVKMETSIKADPDEEQWLAAMKDSIEVRMCNLNIVIRSQEEV
DASLEDSVNKHGGRKNFKKFVKTKNPHPQKRIVALKSLRLADGMVTCV

>AIQ85043.1 NBS-LRR disease resistance protein, partial [Musa ABB Group]
MGGVGKTTLAQQAYNPERVKDYFHHKVWVCVSDNFNVERLSKEIIESITENKCDLSNLDTLQVVVKKKLT
SKRFLLVLDDVWNEDSLKWERFCAPLRYGEPGSKILVTTRSKKIAEMVGNPFPLGGLDEASYWKLFKKCA
FGSEYAGE

>AIQ85044.1 NBS-LRR disease resistance protein, partial [Musa laterita]
GGGGKTSLAQQAYNHERVKDYFHHKVWVCVSDNFNVERLTKEIIESLTRNKWDLNNLDTLQVVVKEELTS
KRFLLVLDDVWNEDSLKWERFCAPLRYGEPGSKILVTTRSKKIAEMVGNPIPLGGLDEASYWELFKKCAF
GSEDAGE

>AIQ85045.1 NBS-LRR disease resistance protein, partial [Musa laterita]
MGGVGKTTLAQQAYNHERVQDYFQHEVWVCVSDNFNVERLTKEIIESITENKCDLSNLDTLQVVLKKNLT
SKRFLLVLDDVWNEDSLKWERFCAPLRYGEPGSKILVTTRSKNVFENGWNPIPLGGLDEASYWKLFKKCA
FGSEDAGEFPHLE

>AAM28915.1 NBS, partial [Pinus taeda]
TRFDWKEQLHRLQHVLPSETQEKLXFGYLNLNREERQMFLDSACFFIGQKRDTAIRIWEGSLWDGHSGFL
TLQHRCLLGVDDENNIEXHDHLRDFGRAACPNRFLPSWIPMDSLRVLQVSGSVLKTLWEDDSQPPLQLRE
LEINAPLSNIPGSIGRLKHLERFVVGKYLSGQVNLTELPVEFCHLQSLKALVLTECSKIKSLPEFGALLM
WLRHIDLSFCRNLERLPDSLHYLSHLRLINLSDCHDLVTLPDNIGRLRCLQHIDLQGCHNLERLPDSFGE
LTDLRHINLSGCHDLQRLPDSFGKLRYLQHIDLHGCHSLEGLPISFGDLMNLEYINLSNCHNLERLPESI
GNLSDLRHIDLSGCHNLERLPDNFRELEELRYLDVEGCSNLIIDRFEIIGISDNLPVAHQVNWNKY

+ +

4.3 Python中正则表达式re包

==新包学习思路总结：==

+
    +
  1. 学习里面的函数/方法
    2. +
  2. 类实例化后对象的学习(方法，属性)
    3. +
  3. 都有哪些类，类之间的关系
    4. +
+

re包中常用方法

    +
  1. re.search(pattern, string, flags=0)
    2. +
  2. re.match(pattern, string, flags=0)
    3. +
  3. re.findall(pattern, string, flags=0)
    4. +
+

参数说明

+
    +
  • pattern 匹配的正则表达式
    • +
  • string 要匹配的字符串。
    • +
  • flags 用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。见：正则表达式修饰符
    • +
+

注意区别：

re.match与re.search的区别
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

+

re.match和re.search 与findall的区别：
前面两个找到一个就结束，findall会找到所有。
返回对象不同，findall返回列表，

+

正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
修饰符描述
re.I忽略大小写
re.M多行匹配，影响 ^ 和 $
re.U根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.L做本地化识别（locale-aware）匹配
re.S使 . 匹配包括换行在内的所有字符
re.X该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
+

代码示例：

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import re
 
line = "Cats are smarter than dogs"
 
matchObj = re.match( r'dogs', line, re.I)
if matchObj:
   print("match --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")


line = "Cats are smarter than Dogs"
matchObj = re.search( r'dogs', line, re.I)
if matchObj:
   print ("search --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")
+ + + +

匹配对象的方法 得到详细的搜索匹配结果

    +
  • group() 返回被 RE 匹配的字符串。
    • +
  • start() 返回匹配开始的位置
    • +
  • end() 返回匹配结束的位置
    • +
  • span() 返回一个元组包含匹配 (开始,结束) 的位置
    • +
+

更多方法及帮助：https://docs.python.org/zh-cn/3.7/library/re.html#match-objects

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import re


line = "Cats are smarter than dogs";
 
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
 
if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"
   
   
print(re.search('www', 'www.omicsclass.com').span())  # 在起始位置匹配
print(re.search('com', 'www.omicsclass.com').span())         # 不在起始位置匹配
+ + +

搜索替换

Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。支持正则表达式，比字符串自带的replace方法功能更强大。

+

语法：

+
+

re.sub(pattern, repl, string, count=0, flags=0)

+
+
    +
  • pattern : 正则中的模式字符串。 (搜索的内容)
    • +
  • repl : 替换的字符串，也可为一个函数。 (替换的内容)
    • +
  • string : 要被查找替换的原始字符串。 (在哪里搜索替换)
    • +
  • count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
    • +
  • flags 用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。见：正则表达式修饰符
    • +
+
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
import re
 
tel = "010-8054-3251,www.omicsclasss.com"

# 删除字符串中的 数字 
num = re.sub(r"^\d+-\d+-\d+,", "", tel)
print("Website is:", num)
 
# 删除数字
num = re.sub(r'\d+', "", tel)
print("telphone num : ", num)



### 高级用法 （选修）
#repl 参数是一个函数
#以下实例中将字符串中的匹配的数字乘以 2：

# 将匹配的数字乘以 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
 
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))
+

re.split 方法支持正则表达式：

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：

+
+

re.split(pattern, string[, maxsplit=0, flags=0])

+
+
    +
  • pattern 匹配的正则表达式
    • +
  • string 要分割的字符串。
    • +
  • maxsplit 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
    • +
  • flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
    • +
+
1
2
3
4
5
6
7
8
9
import re
re.split(r'[,;=]', 'omicsclass, omicsclass;omicsclass.')
re.split(r'\s+', ' omicsclass, omicsclass, omicsclass.') 
re.split(r',', ' omicsclass, omicsclass, omicsclass.', 1) 

 
re.split(r'\t', 'hello world')   # 对于一个找不到匹配的字符串而言，split 不会对其作出分割
['hello world']

+ + +

re.compile 方法

compile 方法用于编译正则表达式，提前编译后的正则表达式可以加快正则表示的匹配速度；编译后生成一个正则表达式（ Pattern ）对象。

+

语法格式为：

+
+

re.compile(pattern[, flags])

+
+
    +
  • pattern : 一个字符串形式的正则表达式
    • +
  • flags 用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。见：正则表达式修饰符
    • +
+
Pattern正则表达式对象 （正则对象）

常见方法：

+
    +
  • Pattern.findall(string[, pos[, endpos]])
    • +
  • Pattern.search(string[, pos[, endpos]])
    • +
  • Pattern.match(string[, pos[, endpos]])
    • +
+

参数：

+
    +
  • string : 待匹配的字符串。
    • +
  • pos : 可选参数，指定字符串的起始位置，默认为 0。
    • +
  • endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。
    • +
+

注意： match 和 search 是匹配一次 findall 匹配所有。

+

更多方法：https://docs.python.org/zh-cn/3.7/library/re.html#regular-expression-objects

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import re
 
p = re.compile(r'\d+')   # 查找数字
result1 = p.findall('omicsclass 123 google 456')
result2 = p.findall('runomicsclass123google456', 0, 10)
 
print(result1)
print(result2)



result3=p.search("runomicsclass123google456")
result4=p.match("runomicsclass123google456")

print(result3)
print(result4)

#或者也可以这样用
result5=re.search(p,"runomicsclass123google456")
result6=re.match(p,"runomicsclass123google456")

print(result5)
print(result6)
+ + + +

正则表达式处理文件主要用处

    +
  1. split分隔文件
    2. +
  2. 查找是否含有某某字符，配合IF判断
    3. +
  3. 在字符串中捕获信息
    4. +
+

练习

从GFF文件中提取基因ID及位置信息存成表格(注意用正则表达式的捕获功能完成)

+

GFF 文件（人1号染色体上基因注释信息）地址：ftp://ftp.ensembl.org/pub/release-98/gff3/homo_sapiens/Homo_sapiens.GRCh38.98.chromosome.1.gff3.gz

+

答案：

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import re

fr=open("D:\\python_script\\Homo_sapiens.GRCh38.98.chromosome.1.gff3\\Homo_sapiens.GRCh38.98.chromosome.1.gff3","r")

fw=open("D:\\python_script\\chr1.txt","w")

for line in fr:
    if re.match("#",line):
        continue
        
    tmp=re.split("\t",line)
    if tmp[2] == "gene":
        mobj=re.search("ID=gene:([^;]+)",tmp[8]) #捕获基因ID
        if mobj:
            fw.write("\t".join([tmp[0],tmp[3],tmp[4],tmp[6],mobj.group(1)])+"\n")
            
fr.close()
fw.close()
+ + +
+

5 Python biopython包处理生物数据

5.1 BioPython包

image

+

专门用于处理生物数据的包，主要功能如下：

+

（1）biopython处理生物数据

    +
  • Blast output – both from standalone and WWW Blast
    • +
  • Clustalw
    • +
  • FASTA/FASTQ
    • +
  • GenBank
    • +
  • PubMed and Medline
    • +
  • ExPASy files, like Enzyme and Prosite
    • +
  • SCOP, including ‘dom’ and ‘lin’ files
    • +
  • UniGene
    • +
  • SwissProt
    • +
+

（2）在线链接生物数据库，实时处理数据

    +
  • NCBI – Blast, Entrez and PubMed services
    • +
  • ExPASy – Swiss-Prot and Prosite entries, as well as Prosite searches
    • +
+

（3）与生物信息常用软件交户，实现批量处理分析数据

    +
  • Standalone Blast from NCBI
    • +
  • Clustalw alignment program
    • +
  • EMBOSS command line tools
    • +
+

获取帮助：

官方网站：https://biopython.org/

+

帮助文档：http://biopython.org/DIST/docs/tutorial/Tutorial.pdf

+

中文帮助文档（Last Update – 22 March 2013 (Biopython 1.61+)）：https://biopython-cn.readthedocs.io/zh_CN/latest/

+

安装

1
2
3
4
5
6
pip install biopython -i  https://pypi.tuna.tsinghua.edu.cn/simple #安装
pip install --upgrade biopython  #更新
pip uninstall biopython  #卸载

#导入包：
import Bio
+

5.2 利用biopython处理序列(fasta，fastq等)

Seq序列对象与SeqRecord注释对象学习

Seq对象中文帮助： https://biopython-cn.readthedocs.io/zh_CN/latest/cn/chr03.html#chapter-bio-seq

+

SeqRecord注释对象中文帮助： https://biopython-cn.readthedocs.io/zh_CN/latest/cn/chr04.html#chapter-seqrecord

+

5.2.1 Seq序列对象

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
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio.Alphabet import IUPAC
from Bio.SeqUtils import GC

#Seq 对象创建
dna_seq = Seq("AGTACACTGGT", IUPAC.unambiguous_dna)
protein_seq = Seq("EVRNAK", IUPAC.protein)

#序列对象继承了字符串对象一些方法
len(dna_seq)
dna_seq.count("A")
GC(dna_seq)  #计算GC含量
dna_seq[4:12] #切取序列
str(dna_seq)  #将序列对象转换成字符串
my_seq = Seq("ACGT", IUPAC.unambiguous_dna)
my_seq + dna_seq  #连接或添加序列
my_seq.upper()  
my_seq.lower()

#核苷酸序列反向互补序列            
my_seq.reverse_complement()  

#转录
coding_dna = Seq("ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG", IUPAC.unambiguous_dna)
messenger_rna = coding_dna.transcribe()
messenger_rna.back_transcribe()  #从mRNA逆向转录为DNA编码链的方法

#翻译  https://biopython-cn.readthedocs.io/zh_CN/latest/cn/chr03.html#sec-translation
coding_dna.translate()

+ + +

Bio.Alphabet.IUPAC 提供了蛋白质、DNA和RNA的基本定义：

+
    +
  • IUPAC.protein 蛋白质
    • +
  • IUPAC.unambiguous_dna DNA
    • +
+

更多编码见：https://www.omicsclass.com/article/409

+

5.2.2 SeqRecord序列注释对象

SeqRecord 类非常简单,包括下列属性:

+

.seq
– 序列自身（即 Seq 对象）。

+

.id
– 序列主ID（-字符串类型）。通常类同于accession number。

+

.description
– 序列描述（-字符串类型）。

+

.name
– 序列名/id （-字符串类型）。 可以是accession number, 也可是clone名（类似GenBank record中的LOCUS id）。

+

.letter_annotations
– 对照序列的每个字母逐字注释（per-letter-annotations），以信息名为键（keys），信息内容为值（value）所构成的字典。值与序列等长，用Python列表、元组或字符串表示。.letter_annotations可用于质量分数(如第 18.1.6 节) 或二级结构信息 (如 Stockholm/PFAM 比对文件)等数据的存储。

+

.annotations
– 用于储存附加信息的字典。信息名为键（keys），信息内容为值（value）。用于保存序列的零散信息（如unstructured information）。

+

.features
– SeqFeature 对象列表，储存序列的结构化信息（structured information），如：基因位置, 蛋白结构域。

+

.dbxrefs
– 储存数据库交叉引用信息（cross-references）的字符串列表。

+

SeqRecord对象创建

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
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio.Alphabet import IUPAC

simple_seq = Seq("CCCTTCTTGTCTTCAGCGTTTCTCC", IUPAC.unambiguous_dna)
simple_seq_r = SeqRecord(simple_seq, id="AC12345",description="just a test sequence")

#属性后添加和修改
simple_seq_r.description = "just a test sequence"

simple_seq_r.seq
simple_seq_r.id
simple_seq_r.description

#如果是fastq文件，可以添加序列质量值注释信息

simple_seq_r.letter_annotations["phred_quality"] = [26, 26, 18, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 22, 26, 26, 26, 26,
26, 26, 26, 23, 23]
print(simple_seq_r.letter_annotations)
print(simple_seq_r.letter_annotations["phred_quality"])


#序列截取：

simple_seq_r[0:2]

+ +

SeqRecord对象从文件中获得

fasta/fastq文件读写，得到SeqRecord对象；

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#fasta文件读取得到SeqRecord对象
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os

os.chdir("D:\\python_script")
output_handle = open("out.fa", "w")
for rec in SeqIO.parse("test.fa", "fasta"):
    seq=rec.seq
    seq_r = SeqRecord(seq[0:10],id=rec.id,description=rec.description)
    SeqIO.write(seq_r, output_handle, "fasta")

output_handle.close()
+

5.3 练习

任务：利用biopython处理fasta/fastq序列
    +
  1. 任务: 提取指定ID的fasta序列
    2. +
  2. 任务: 截取fasta序列中指定位置的序列
    3. +
  3. 任务: fastq文件转换成fasta文件
    4. +
  4. 任务: fastq文件去掉前5个碱基
    5. +
+

fa文件：

+
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
>AT1G66550.1 cds chromosome:TAIR10:1:24828537:24829589:1 gene:AT1G66550 gene_biotype:protein_coding transcript_biotype:protein_coding gene_symbol:WRKY67 description:Probable WRKY transcription factor 67 [Source:UniProtKB/Swiss-Prot;Acc:Q93WV7]
ATGGTTTCCAACATTGATCACAAGGCTATGGAAGCACTCCTCCGTGGCCAAGGATGCGCT
AACAACCTCAAGATTCTCCTTGAAAACGGCGAAATAAGCTCAGTTTCAACAGAACCACTC
ATCCACACCATTCTCGATTCTTTCTCACTTGCTCTGTCTTTTATGGATTCTCCTAATCAT
CCACCATACCATGAATCCTCTTCTCATAACATGGCAAGTCATATGTCCCGGAGATCATCT
AAGCAAGTACAACATCGCAGAAAACTTTGTGTAGCAGAAGGTTTAGTGAATTACAATCAC
GATTCCCGGACTATGTGCCCCAATGATGGCTTCACCTGGAGGAAATATGGACAAAAAACC
ATTAAAGCCTCAGCGCACAAAAGGTGTTACTATCGGTGTACCTATGCAAAAGACCAAAAC
TGCAATGCTACAAAGCGGGTGCAGAAGATCAAAGACAACCCTCCAGTGTACAGAACCACT
TACTTGGGAAAACATGTGTGTAAAGCTTTTGCAGTTCATGATGATACATATAGTTCCACG
ATGATTCGATTCGACCAAGTTGTTCCTGAACCGATTATGCCGCAGCTCACAACAATTGAC
CACCAAGTAATTACCGTGGAGGAAAACTCCGCAGAACATATCATGAACCAAGAATGTGAT
ATTAATGATTATTTGGTGGATGATGACCCATTTTGGGCTAGTCAATTTCCCCCGTTTCCA
TCGAGTGACACAATGTTCTTGGAAAACATTTCTGCTTTTGATTAG
>AT4G39410.1 cds chromosome:TAIR10:4:18332606:18334893:-1 gene:AT4G39410 gene_biotype:protein_coding transcript_biotype:protein_coding gene_symbol:WRKY13 description:WRKY13 [Source:UniProtKB/TrEMBL;Acc:A0A178UV80]
ATGGGTGCGATAAACCAAGGAATAAGCTTGTTTGATGAATCACAAACCGTCATAAACCCT
ATTAATACCAACCATCTAGGTTTCTTCTTCTCTTTCCCTAGTCACAGCACCTTATCTTCA
TCATCTTCGTCGTCTTCGTCTTCTCCTTCTTCTCTTGTGTCTCCATTTCTTGGTCATAAC
TCCCTAAACTCCTTCCTTCATAATAACCCGTCTTCATTCATAAGTCATCCTCAAGATTCC
ATCAATCTCATGACCAATCTCCCCGAAACCCTAATCTCGTCTTTGTCCTCATCAAAGCAA
AGGGACGATCATGATGGTTTTCTTAATCTCGATCATCATCGTCTTACCGGTAGTATTTCA
TCCCAAAGACCCCTGTCAAATCCATGGGCATGGAGTTGTCAAGCGGGATACGGAAGCAGC
CAGAAAAACAACCATGGAAGCGAGATTGATGTTGATGATAATGATGATGAGGTTGGCGAT
GGTGGTGGCATTAATGATGATGATAATGGTCGTCATCATCATCATGATACTCCCAGTCGT
CATGATAAACATAACACAGCGTCATTAGGCGTAGTTTCTTCTCTGAAGATGAAGAAGCTT
AAGACAAGAAGAAAAGTGAGGGAACCTCGGTTTTGCTTTAAGACACTTAGCGAGGTTGAT
GTCTTAGATGATGGATATAGATGGAGAAAGTATGGCCAGAAAGTTGTCAAAAACACCCAA
CATCCCAGGAGCTATTACAGATGCACACAAGACAAGTGTAGAGTGAAGAAGAGAGTGGAG
AGATTAGCAGATGACCCAAGAATGGTAATCACTACTTACGAAGGAAGACACCTTCACTCT
CCTTCTAATCATCTCGACGACGACTCTCTCTCCACCTCTCACCTGCACCCTCCTCTCTCC
AACTTCTTCTGGTGA
>AT4G18170.1 cds chromosome:TAIR10:4:10061214:10062893:1 gene:AT4G18170 gene_biotype:protein_coding transcript_biotype:protein_coding gene_symbol:WRKY28 description:WRKY28 [Source:UniProtKB/TrEMBL;Acc:A0A178V3M3]
ATGTCTAATGAAACCAGAGATCTCTACAACTACCAATACCCTTCATCGTTTTCGTTGCAC
GAAATGATGAATCTGCCTACTTCAAATCCATCTTCTTATGGAAACCTCCCATCACAAAAC
GGTTTTAATCCATCTACTTATTCCTTCACCGATTGTCTCCAAAGTTCTCCAGCAGCGTAT
GAATCTCTACTTCAGAAAACTTTTGGTCTTTCTCCCTCTTCCTCAGAGGTTTTCAATTCT
TCGATCGATCAAGAACCGAACCGTGATGTTACTAATGACGTAATCAATGGTGGTGCATGC
AACGAGACTGAAACTAGGGTTTCTCCTTCTAATTCTTCCTCTAGTGAGGCTGATCACCCC
GGTGAAGATTCCGGTAAGAGCCGGAGGAAACGAGAGTTAGTCGGTGAAGAAGATCAAATT
TCCAAAAAAGTTGGGAAAACGAAAAAGACTGAGGTGAAGAAACAAAGAGAGCCACGAGTC
TCGTTTATGACTAAAAGTGAAGTTGATCATCTTGAAGATGGTTATAGATGGAGAAAATAC
GGCCAAAAGGCTGTAAAAAATAGCCCTTATCCAAGGAGTTACTATAGATGTACAACACAA
AAGTGCAACGTGAAGAAACGAGTGGAGAGATCGTTCCAAGATCCAACGGTTGTGATTACA
ACTTACGAGGGTCAACACAACCACCCGATTCCGACTAATCTTCGAGGAAGTTCTGCCGCG
GCTGCTATGTTCTCCGCAGACCTCATGACTCCAAGAAGCTTTGCACATGATATGTTTAGG
ACGGCAGCTTATACTAACGGCGGTTCTGTGGCGGCGGCTTTGGATTATGGATATGGACAA
AGTGGTTATGGTAGTGTGAATTCAAACCCTAGTTCTCACCAAGTGTATCATCAAGGGGGT
GAGTATGAGCTCTTGAGGGAGATTTTTCCTTCAATTTTCTTTAAGCAAGAGCCTTGA
>AT5G45050.1 cds chromosome:TAIR10:5:18176914:18181973:-1 gene:AT5G45050 gene_biotype:protein_coding transcript_biotype:protein_coding gene_symbol:RRS1B description:Probable WRKY transcription factor 16 [Source:UniProtKB/Swiss-Prot;Acc:Q9FL92]
ATGACCGAGAGTGAGCAAATCGTCTACATCAGCTGCATAGAGGAGGTACGATACTCCTTC
GTCAGCCACCTCTCCAAAGCTCTCCAGCGAAAAGGTGTAAACGATGTCTTCATCGATAGC
GATGATTCGCTTTCCAACGAGTCTCAATCAATGGTCGAGAGAGCTAGGGTTTCTGTTATG
ATTTTACCAGGAAACCGTACGGTATCTCTTGACAAGCTCGTGAAGGTTCTCGATTGCCAG
AAGAACAAAGATCAAGTGGTGGTTCCGGTGTTGTACGGTGTCAGATCATCAGAGACCGAA
TGGCTTAGCGCGCTGGATTCGAAAGGATTCTCATCAGTACACCATTCCAGGAAAGAATGT
AGTGACTCCCAGCTTGTAAAAGAGACTGTTAGAGATGTGTATGAGAAGCTCTTTTATATG
GAACGAATTGGAATATATTCGAAGCTGCTGGAGATTGAGAAAATGATTAACAAGCAACCG
TTGGACATCCGTTGTGTTGGAATTTGGGGTATGCCTGGCATAGGCAAGACTACACTTGCT
AAAGCAGTCTTTGACCAAATGTCTGGTGAGTTTGATGCTCATTGCTTTATTGAAGACTAC
ACCAAAGCTATTCAAGAGAAGGGTGTTTATTGTTTGCTGGAGGAACAGTTTTTGAAAGAA
AATGCTGGTGCTAGTGGTACCGTTACGAAATTGAGCTTGCTTAGGGATAGATTAAACAAT
AAGAGGGTTCTTGTTGTTCTTGATGATGTCCGCAGTCCTCTGGTTGTGGAGTCTTTTCTT
GGAGGGTTTGACTGGTTTGGTCCCAAAAGTCTAATCATCATAACCTCCAAAGATAAATCG
GTGTTTCGCCTTTGTCGAGTCAATCAAATATACGAGGTTCAGGGTTTAAATGAGAAAGAG
GCTCTTCAACTCTTCTCTTTGTGTGCGTCTATAGACGATATGGCAGAGCAGAATCTCCAC
GAGGTGTCAATGAAAGTTATTAAATATGCTAATGGCCATCCATTAGCTCTCAATCTCTAT
GGCAGAGAACTGATGGGGAAGAAAAGACCACCAGAAATGGAGATAGCATTCCTCAAACTC
AAGGAATGTCCTCCAGCTATTTTTGTTGATGCAATCAAGAGCTCGTATGACACACTCAAT
GACAGGGAAAAAAACATTTTTTTGGACATAGCTTGTTTCTTCCAGGGAGAAAATGTTGAC
TACGTGATGCAACTGCTTGAGGGTTGTGGTTTCTTTCCACATGTTGGAATTGATGTTCTT
GTGGAGAAGAGTCTGGTGACTATTTCAGAAAACCGAGTGCGGATGCATAACTTGATCCAA
GATGTTGGCCGACAAATAATAAATAGAGAAACAAGACAGACTAAGAGGCGCAGCAGACTG
TGGGAACCTTGCAGCATCAAATATTTATTAGAAGATAAGGAACAAAACGAAAATGAAGAA
CAAAAAACAACTTTTGAACGTGCTCAGGTCCCTGAAGAGATCGAAGGCATGTTTCTGGAC
ACATCAAACTTAAGTTTTGATATTAAGCATGTTGCCTTTGATAATATGTTGAACCTTAGA
TTGTTCAAGATTTACAGTTCCAATCCTGAAGTCCATCATGTAAACAATTTCCTCAAAGGC
TCTCTCAGTTCTCTTCCTAATGTGCTAAGACTCCTGCATTGGGAGAACTATCCTCTGCAG
TTTCTGCCTCAAAATTTTGATCCTATACACCTTGTTGAAATCAACATGCCGTACAGCCAA
CTTAAGAAACTTTGGGGTGGAACCAAGGACCTGGAGATGTTGAAGACAATCAGGCTTTGT
CATTCCCAACAACTAGTTGATATTGACGATCTTTTAAAAGCTCAAAATCTTGAGGTAGTT
GATCTCCAAGGCTGTACAAGACTGCAGAGTTTCCCAGCCACCGGTCAATTGCTACATTTA
CGAGTTGTAAATCTCTCAGGTTGCACAGAGATCAAAAGTTTCCCAGAAATTCCCCCAAAT
ATTGAGACACTGAATCTACAGGGGACTGGTATAATAGAATTACCACTTTCCATTGTTAAG
CCAAACTACAGAGAGCTTTTGAATCTTCTAGCTGAAATCCCGGGTCTTTCAGGTGTCTCA
AACCTTGAGCAAAGTGATCTCAAACCTTTAACAAGCCTGATGAAAATTAGCACATCTTAC
CAAAATCCTGGCAAGCTTAGTTGCTTGGAGCTGAATGATTGTTCTCGTTTGCGAAGTCTG
CCAAACATGGTTAATTTAGAACTTCTCAAAGCCCTTGATCTTTCTGGTTGCTCAGAGCTC
GAGACTATCCAGGGTTTCCCACGGAACCTGAAAGAGTTATATCTTGTTGGCACTGCAGTA
AGACAAGTGCCACAACTTCCTCAAAGTCTAGAATTCTTTAATGCCCATGGTTGTGTCTCT
CTCAAATCAATTCGTTTGGACTTCAAGAAGCTTCCTGTGCATTACACATTTAGTAATTGT
TTCGATCTATCTCCACAAGTGGTCAACGATTTTTTAGTGCAGGCGATGGCTAATGTGATT
GCAAAACACATACCAAGAGAGCGTCATGTCACAGGCTTTTCTCAAAAGACTGTGCAGCGT
TCGAGTCGTGACAGTCAGCAGGAACTCAACAAAACTTTGGCTTTCAGCTTCTGTGCGCCC
TCACATGCGAATCAAAATTCCAAACTTGATCTGCAACCAGGATCTTCTTCAATGACACGA
CTAGATCCTTCTTGGAGGAACACACTTGTGGGCTTTGCTATGCTGGTGCAAGTCGCATTT
TCCGAGGGTTACTGTGATGATACTGATTTTGGCATTAGTTGTGTTTGCAAATGGAAAAAC
AAGGAAGGCCACTCTCATAGGAGAGAAATAAATTTGCATTGTTGGGCTTTAGGGAAAGCT
GTTGAAAGGGATCATACGTTTGTCTTCTTTGATGTCAACATGCGTCCAGATACCGATGAA
GGAAATGACCCCGATATCTGGGCTGATTTAGTTGTTTTTGAGTTCTTTCCTGTCAATAAA
CAGAGAAAGCCTCTAAATGATAGTTGCACAGTGACAAGATGTGGAGTCCGTTTAATAACT
GCTGTAAACTGCAATACAAGTATCGAGAATATATCACCAGTTTTGTCCTTGGATCCGATG
GAGGTTTCTGGTAATGAAGATGAAGAAGTATTGAGAGTCAGATATGCTGGTTTACAGGAG
ATATATAAAGCTTTGTTTCTTTACATAGCGGGTTTGTTCAATGACGAGGATGTTGGTTTG
GTAGCACCACTTATTGCTAACATTATTGACATGGACGTTAGTTATGGGCTCAAGGTCTTA
GCCTATAGGTCTCTCATACGTGTATCTTCCAATGGGGAAATAGTGATGCACTATTTGCTA
CGACAAATGGGTAAAGAAATCCTCCATACAGAATCAAAGAAGACTGACAAATTAGTCGAC
AATATTCAGAGTTCCATGATCGCAACAAAGGAAATCGAGATCACTCGTTCAAAGAGTCGC
CGAAAGAACAACAAGGAAAAGAGAGTGGTTTGCGTAGTGGATCGAGGCAGCCGGTCCAGT
GACCTATGGGTTTGGCGAAAGTATGGTCAAAAACCCATCAAAAGTTCTCCTTATCCAAGG
AGTTACTATAGATGTGCCAGCTCGAAAGGTTGTTTTGCTAGGAAACAAGTCGAACGTAGC
CGCACTGATCCAAATGTTTCAGTAATTACTTACATCTCTGAGCATAACCATCCATTCCCC
ACTCTACGCAATACTCTTGCCGGCTCCACTCGTTCCTCTTCCTCCAAATGCTCAGATGTA
ACTACTTCTGCCTCATCGACAGTCTCCCAAGACAAAGAAGGACCGGATAAATCCCATTTG
CCTTCCTCCCCTGCTTCTCCTCCTTATGCGGCCATGGTGGTTAAGGAGGAGGACATGGAG
CAATGGGACAATATGGAGTTCGATGTTGACGTTGAAGAAGATACTTTCATACCCGAATTA
TTTCCAGAGGATACCTTCGCTGATATGGACAAGCTTGAGGAAAATTCTCAGACTATGTTT
CTCTCTCGCAGAAGCAGCGGAGGCAACATGGAAGCCCAAGGGAAGAACTCTAGTGATGAT
AGGGAGGTCAATTTACCTAGTAAAATTCTGAATAGATAG

+ +

fastq文件 ：
详细介绍可以观看：https://www.omicsclass.com/course/28

+
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
@A00808:122:HM2JCDSXX:1:1101:3025:1000 1:N:0:TCGGAAGT+ACAAGGCT
AATTATTCCAAGTGATCATTTAATTTAACAGTACGTTATTACAGTTTTTGACAATACACCAGGAGGGGCAGAAGCAGCACTCCATTTATGCGCCGAATTCTCGTACAGACACACACACACACACAGATTCACACAGTCAATTCAGTCCTT
+
FFFFFFFFFFFF:FFFF:FFFFFFFFFFFFFFFFFFF,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:
@A00808:122:HM2JCDSXX:1:1101:4399:1000 1:N:0:TCGGAAGT+ACAAGGCT
CTTTGCTATAAACTAAGTCACCTTCTACAGCCTGCGAAATGCCATATTTTTCAACTCTGGCACTGGCAGCATGGTTCCAGAGGTAACTTTGGTAACTATGAACGTACATCATTCGTAATGTTCTTGGTATACTCTTTAATGCTTGCAGAT
+
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:F,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
@A00808:122:HM2JCDSXX:1:1101:8522:1000 1:N:0:TCGGAAGT+ACAAGGCA
NACTTTTCAGATTTCAACTTGAGAGATGGACCATCAAGAGCCTTTTTCATGTCACGTTTTTGAGCCATACAATGATACAGACGAAAGAAAACAAGCCAAACAACTCATCCAACCGACCGCGAACAGTAGACACAATTACACAAACACATG
+
#FFF,:FFF:,:FFF:F:FF:FFFFFF:FFF,F:FFF,F,:FF,:FFFF:FFFFF:FF,FF::,,FFFFFFFF:F:FFF,,,FFFFFF,FFF,:,:F::FFFFFFFFFFFFFF,FFFFFF:FFF,,F:,,F:F,:,FFF:,,FF:,FFFF
@A00808:122:HM2JCDSXX:1:1101:13205:1000 1:N:0:TCGGAAGT+ACAAGGCT
NTTCGACGAGGAGGCCGCCTGCGCGCGCGACGCCGCCGGGGAGGCCCTCGCGGCCTTCGAGTCGCTGCTCGCGCGCCTCCCCCCGCCCGACGCCGACTCGCGCCGCCGATCCATGGGGCTCAAGTTGGAGCAGCACAAAGCCGAGCTCAA
+
#FFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFF,F:FFFF,FFFFF,F,FFFFFF:FF:FF:FF:,:,,F,FFFFF,F,:F:FFF:,F,FFFFF,F,:,,,FFF::,:FFFF,FF:,:,:,,FFF,F,FF,,FFFFF,FFFF,FFFF
@A00808:122:HM2JCDSXX:1:1101:3902:1016 1:N:0:TCGGAAGT+ACAAGGCT
GTCGTCGTCACCGAATGTTGTCTTCTTTCCTGCACTAGGTGTACCAGCGCTCTGCTTGAACGGTGTACCCCGTCCACCACGGCCCCTGTCACCCCTACCAAAGCCTCTACCACGTCCACGGTCACCGCGCCCACGGCTACCATCACCACG
+
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFF
@A00808:122:HM2JCDSXX:1:1101:20518:1016 1:N:0:TCGGAAGT+ACAAGGCT
NGCTGGAGAACTAAGTGTCGATCTTCACCTTCACCAACAGATTCATGAACAAACCTAGCAGCGACACAAAAGCAAGACATTAGTAGTTGCAAATATTACTCTATCCAGTTAAGTTAGTATTTGAGAAGAGGGTAGGTGAAGCAGGTCGAA
+
#FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,FFFFFFFF:F,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
@A00808:122:HM2JCDSXX:1:1101:23158:1016 1:N:0:TCGGAAGT+ACAAGGCT
NTCCCTGGACTCTGGGGCACTTTAGGGCTAGGAACACTTGTCAAGCGACTCTGAGGCACAGTATCAGACATGGACTTCGAGAAGGCTTGTGCAAGCTCCAATGCAGATGCTCCTTTCCCAAAACGAGGTGCAACAACCTCAGGCTTTGGT
+
#FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFF
@A00808:122:HM2JCDSXX:1:1101:1597:1031 1:N:0:TCGGAAGT+ACAAGGCT
CGCCGCCGCACTCTGCAACCGCGCCGCGGGGAGGGAGGGAAGGACGAAGGAGGAAGGAGATGGAGCGGGTCGGCGGCGGGGAGAAGCAGCTGGAGGACTGCACCGTGTCCAATGCTCTCGGCACCTGGTTCTTCTCAGTTGCTGGTGCTC
+
F:FFFFFFFFFFFFFFFFFFFFFFFFFF,FF:FFF:FFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,FFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFF
@A00808:122:HM2JCDSXX:1:1101:3351:1031 1:N:0:TCGGAAGT+ACAAGGCT
CCCCCTTGAACTATCCGTAAATACCACCATTCCACCAAACTCCCCTCTGTCTTCTACGACAAATAATCTTTTCAACCCAGTAACTTATAATTAATTACAGAGAGATTAGCAAACATATAATGGTAAGAATCAGTTGTCGTAGGTGCGGCA
+
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFF:FF,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFF
@A00808:122:HM2JCDSXX:1:1101:5466:1031 1:N:0:TCGGAAGT+ACAAGGCT
CTCGCAGTGCTTGGTGTACTTGGCCGGGTCCAGCAGGGCGTCCAGCTCCGACGGGCTGCTCGGCTTCACCTTGATCATCCACCCGTCCTCGTACGGGCTTGAGTTAATCAGGCCGGGTGTCTCAGAGAGCTTGTCGTTAACCTCGACGAC
+
:FF:FF:F,FFFFF,FFFF:::FFF,F::F:F:,F,,,FFF:F::FFFF:FFF:F,:::FF:F,:FFFFFFFFFF,FFFFFFF::FFFF:FFFFFFFF:,FFFFFFFF,F,FF,F,FFF,:F,FFF,FFFF,FFFFF,F:,FFFFFFFFF
@A00808:122:HM2JCDSXX:1:1101:6714:1031 1:N:0:TCGGAAGT+ACAAGGCT
CGACGAGATCGGCCGCTCCGAATCCGATCCGCGCACGTGGTCTCGCCGGCGGGGTCAGGTTGGTTCGCGGGAGCCGCCGCCGCCGCCGACGACGACGACGATGGCCATGGAGACGCCGCCGCCGTTCCAGGAGTCCGCCCACTGCGACGT
+
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

+ +

==任务1 答案：==

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os

os.chdir("D:\\python_script")

idlist={}  #字典用于存储ID列表
f = open("idlist.txt", "r")  #打开ID列表文件
for line in f:
    line=line.strip()
    idlist[line]=1
f.close()

f_out = open("get.fa", "w")
for rec in SeqIO.parse("test.fa", "fasta"):
    if rec.id in idlist:  #判断ID是否存在与ID列表字典中
        SeqIO.write(rec,f_out,"fasta")   #如果存在写出该序列
        
f_out.close()
+

==任务2 答案：==

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os
import re
os.chdir("D:\\python_script")

idlist={}  #字典用于存储ID列表以及位置
f = open("id_pos.txt", "r")  #打开ID列表文件
for line in f:
    line=line.strip()
    tmp=re.split(r"\t",line)
    idlist[tmp[0]]=[int(tmp[1]),int(tmp[2])]
f.close()

f_out = open("get_pos.fa", "w")
for rec in SeqIO.parse("test.fa", "fasta"):
    if rec.id in idlist:  #判断ID是否存在与ID列表字典中
        start=idlist[rec.id][0]  #取得对应ID要截取的起始位置
        end=idlist[rec.id][1]   #取得对应ID要截取的结束位置
        rec_new=SeqRecord(rec.seq[start-1:end],id=rec.id,description=rec.description) #注意生物数据一般是从1作为索引，编程语言一般是从0开始所以要减一
        SeqIO.write(rec_new,f_out,"fasta")   #写出截取好的序列
        
f_out.close()
+ +

==任务3 答案：==

+
1
2
3
4
5
6
7
8
9
10
11
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os

os.chdir("D:\\python_script")
output_handle = open("fq2fa.fa", "w")
for rec in SeqIO.parse("test.fq", "fastq"):
    SeqIO.write(rec, output_handle, "fasta")

output_handle.close()
+ + +

==任务4 答案：==

+
1
2
3
4
5
6
7
8
9
10
11
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os

os.chdir("D:\\python_script")
output_handle = open("trimed.fq", "w")
for rec in SeqIO.parse("test.fq", "fastq"):
    rec_new=rec[5:]
    SeqIO.write(rec_new, output_handle, "fastq")
output_handle.close()
+ +

6 Python 中数据统计分析包numpy 与 pandas

6.1 数据统计分析包介绍

    +

  • NumPy：N维数组矩阵容器； 基础的数学计算模块。

    +
    • +

  • Pandas：表格容器； 提供了一套名为DataFrame的数据结构，适合统计分析表格类数据。

    +
    • +

  • SciPy：科学计算函数库； 基于Numpy，提供方法(函数库)直接计算结果；封装了一些高阶抽象的物理模型。比方说做个傅立叶变换，做个滤波器等等。

    +
    • +
+

==非数学研究，建议直接入手Numpy，pandas。目的，是方便我们处理表格类的生物数据。==

+

6.2 Numpy包学习

Numpy：
用来存储和处理大型矩阵，本身是由C语言开发，和列表（list）的使用很像，但是计算速度要比列表快很多。

+ +

6.2.1 安装

1
2
3
4
5
# 使用 pip
pip install numpy -i  https://pypi.tuna.tsinghua.edu.cn/simple

#导入：
import numpy as np
+ +

6.2.2 矩阵/数组创建函数

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
函数描述
np.array()创建数组
np.zeros()创建数据全为0
np.ones()创建数据全为1
np.empty()创建数据接近0
np.arange()按指定范围创建数据
np.linspace()创建线段
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np #为了方便使用numpy 采用np简写
#列表转化为矩阵
a = np.array([2,23,4])
a = np.array([[11, 12, 13, 14, 15],
              [16, 17, 18, 19, 20],
              [21, 22, 23, 24, 25],
              [26, 27, 28 ,29, 30],
              [31, 32, 33, 34, 35]])
print(a)

#指定数据类型
a = np.array([2,23,4],dtype=np.int)
print(a.dtype)

a = np.arange(10,20,2) # 10-19 的数据，2步长
a = np.linspace(1,10,20)    # 开始端1，结束端10，且分割成20个数据，生成线段

a = np.zeros((3,4)) # 数据全为0，3行4列
a = np.ones((3,4),dtype = np.int)   # 数据为1，3行4列
a = np.empty((3,4)) # 数据为empty，3行4列
+ +
数据类型

NumPy支持的数值类型

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
符号含义
np.boolTrue和Flase
np.int支持int的32或64位
np.int88位的整形(-128~127)
np.int16-32768~32767
np.int32-2 ** 31 ~ 2 ** 31 - 1
np.int64-2 ** 63 ~ 2 ** 63 - 1
np.uint88位的整形(0~255)
np.uint16-32768~32767
np.uint320 ~ 2 ** 32 - 1
np.uint640 ~ 2 ** 64 - 1
np.float161位符号位，5位指数位，10位
np.float321位符号位，8位指数位，23位
np.float64、np.float1位符号位，11位指数位，52位
+

6.2.3 特定分布随机数创建矩阵函数

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
函数说明
np.random.rand(d0,d1,…,dn)根据d0-dn(维度)创建随机数数组，[0,1)，均匀分布
np.random.randn(d0,d1,…,dn)根据d0-dn(维度)创建随机数数组，标准正态分布
np.random.randint(low[,high,shape])根据shape创建随机整数或整数数组，范围是[low,high)
np.random.normal(loc,scale,size)产生具有正态分布的数组，loc为均值，scale标准差，size为形状
np.random.permutation(a)根据数组a的第1轴产生一个新的乱序数组，不改变数组a
np.random.choice(a[,size,replace,p])从一维数组a中以概率p抽取元素，形成size形状新数组replace表示是否可能重用元素，默认为False
np.random.uniform(low,high,size)产生具有均匀分布的数组，low起始值，high结束值，size为形状
np.random.poisson(lam,size)产生具有泊松分布的数组，lam为随机事件发生率，size为形状
+
1
2
3
4
5
6
7
8
import numpy as np #为了方便使用numpy 采用np简写

#产生均匀分布的数据，2x3x4 三维数据
np.random.rand(2,3,4) 

# 产生20个均值为2、标准差为0.1满足正态分布的随机数序列
a = np.random.normal(2, 0.1, 20)

+ + + +

6.2.4 矩阵/数组对象相关方法与属性

reshape() 和resize()方法
    +
  • reshape()方法，在reshape方法里以元组、列表给出变化后的形状数据，并不影响原数组会新生成一个多维数组。
    • +
  • resize() 方法，会修改数组本身的shape属性来改变数组的维度，原数组发生改变。
    • +
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import numpy as np


#reshape方法，注意a被修改了
a = np.arange(12)
print(a)
a.reshape((3, 4))  
print(a)

#resize方法，注意a被修改了
a = np.arange(12)
a.resize([3, 4])
print(a)


#通过属性修改维度，注意a被修改了
a = np.arange(12)
print(a)
a.shape = (2, 6)


+ +
数组的一些属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Array properties
import numpy as np
a = np.array([[11, 12, 13, 14, 15],
              [16, 17, 18, 19, 20],
              [21, 22, 23, 24, 25],
              [26, 27, 28 ,29, 30],
              [31, 32, 33, 34, 35]])

print(type(a)) # >>><class 'numpy.ndarray'>    正如你在上面的代码中看到的，NumPy数组实际上被称为：多维数组，ndarray。
print(a.dtype) # >>>int32    数据类型
print(a.size) # >>>25    数据总个数
print(a.shape) # >>>(5, 5)   数组的形状是它有多少行和列，上面的数组有5行和5列，所以它的形状是(5，5)。
print(a.ndim) # >>>2   数组的维数。

+ + + +
矩阵数据支持索引，切片 类似列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import numpy as np
a = np.arange(24)
print (a[3])

#二维数组索引
#对于2D数组：行的切片，列的切片。
a = np.arange(12)
a = a.reshape((3, 4))
print(a[0, 1:4])
print(a[1:4, 0])
print(a[::2,::2])

#三维数组索引
a = np.arange(24)
b = a.reshape((2, 3, 4))
print (b[1,1:2,1:])

+ +
数组支持布尔筛选
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import numpy as np
a = np.arange(0, 100, 10)
b = a[:5]
c = a[a >= 50]
print(b) 
print(c) 


# Where 函数筛选
a = np.arange(0, 100, 10)
b = np.where(a < 50) 
c = np.where(a >= 50)[0]
print(b) 
print(c)
+ + + +

6.2.5 NumPy的数学统计函数

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
函数说明
np.abs() np.fabs()计算数组各元素的绝对值
np.sqrt()计算数组各元素的平方根
np.square()计算数组各元素的平方
np.log(x),np.log10(x),np.log2(x)计算数组各元素的自然对数、10底对数和2底对数
np.ceil(x),np.floor(x)计算数组各元素的ceiling值或floor值
np.rint(x)计算数组各元素的四舍五入值
np.modf(x)将数据各元素的整数和小数部分以两个独立的数组形式返回
np.cos/cosh/sin/sinh/tan/tanh计算数据各元素的普通型和双典型的三角函数
np.exp(x)计算数组各元素的指数值
np.sum(a,axis=None)根据给定axis计算数组a相关元素之和，axis整数或元组
np.mean(a,axis=None)根据给定axis计算数组a相关元素的期望，axis整数或元组
np.average(a,axis=None,weights=None)根据给定axis计算数组a相关元素的加权平均值
np.std(a,axis=None)根据给定轴axis计算数组a相关元素的标准差
np.var(a,axis = None)根据给定轴axis计算数组a相关元素的方差
np.cov(a,axis = None)计算协方差
np.corrcoef计算相关系数，参阅
np.min(a) max(a)计算数组a中元素的最小值，最大值
np.argmin(a) argmax(a)计算数组a中元素的最小值，最大值的降一维后下标
np.unravel_index(index,shape)根据shape将一维下标index转换成多维下标
np.ptp(a)计算数组a中元素最大值和最小值的差
np.median(a)计算数组a中元素的中位数(中值)
+

iris.data测试数据下载：https://archive.ics.uci.edu/ml/machine-learning-databases/iris/

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import numpy as np
import os
os.chdir("D://python_script//")
a, b = np.loadtxt("iris.data",  delimiter=',', usecols = [0, 1],unpack=True)
print(a)
print(b)

print(np.average(a))
print(np.mean(a))
print(np.max(a))
print(np.argmax(a))
print(np.min(a))
print(np.argmin(a), a[np.argmin(a)])
print(np.ptp(a))
print(np.std(a))
print(np.median(a))
print(np.sqrt(a), np.square(a))
print(np.rint(a))
print(np.ceil(a))


#print(np.column_stack([a, b]))
+

NumPy的算术运算，类似线性代数计算

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import numpy as np
# Basic Operators
a = np.arange(25)
a = a.reshape((5, 5))

b = np.array([10, 62, 1, 14, 2, 56, 79, 2, 1, 45,
              4, 92, 5, 55, 63, 43, 35, 6, 53, 24,
              56, 3, 56, 44, 78])
b = b.reshape((5,5))

print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a ** 2)
print(a < b) 
print(a > b)
+ + +

6.3 Pandas简介

基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。最具有统计意味的工具包，某些方面优于R软件。数据结构有一维的Series，二维的DataFrame，三维的Panel。

+ +

Pandas数据类型

    +
  • Series：一维数组，与Numpy中的一维array类似。二者与Python基本的数据结构List也很相近，其区别是：List中的元素可以是不同的数据类型，而Array和Series中则只允许存储相同的数据类型，这样可以更有效的使用内存，提高运算效率。
    • +
  • DataFrame：二维的表格型数据结构。很多功能与R中的data.frame类似。可以将DataFrame理解为Series的容器。
    • +
  • Time-Series：以时间为索引的Series。
    • +
  • Panel：三维的数组，可以理解为DataFrame的容器。则可以视为excel的多表单sheet。
    • +
+

6.3.1 安装

1
2
3
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple/  pandas

import pandas as pd
+ +

6.3.2 创建Series

Series构造函数的name参数是给这列数据指定字段名。从结果可以看出t有两个名为’a’的label，值分别为2和7。

+
1
2
3
4
5
6
7
8
9
10
11
import pandas as pd
i = ["a", "c", "d", "a"]
v = [2, 4, 5, 7]
t = pd.Series(v, index=i, name = "col_name")
print(t)

#数据的访问，支持索引，切片，name取值
print("t[d]->", t["d"])
print('t[0 : 3]->', t[0 : 3])
print('t["a" : "c"]->', t["c" : "d"])  #注意label唯一才行，不然会报错

+ +

image

+

Series对象的方法与属性

get方法

首先看看get方法，可以返回指定的key所对应的value值

+
1
2
3
4
5
6
7
8
import pandas as pd
idx =  "hello the cruel world".split()
val = [1, 21, 13, 104]
t = pd.Series(val, index = idx)

t.get("the")
t.get("The", "None")  #如果key不存在，返回default的值。

+ +
add、append方法

add和append方法都能改变series，只不过add类似于加法操作，而append则是连接。

+
1
2
3
4
5
6
7
8
9
10
11
12
13
import pandas as pd
idx =  "hello the cruel world".split()
val1 = [1, 21, 13, 104]

t = pd.Series(val1, index = idx)

val2 = [4, 4, 4, 4]
s = pd.Series(val2, index = idx)
t.add(s) 
t + 4

t.append(s)

+ +

6.3.3 DataFrame创建

Pandas的Dataframe是二维的，每一列都是一个Series结构。

+
1
2
3
4
5
6
7
8
9
10
11
12
#手动创建
import pandas as pd
import numpy as np
df1 = pd.DataFrame({'A': 1.,
                    'B': pd.date_range('20130101', periods=4),
                    'C': pd.Series(1, index=list(range(4)), dtype='float32'),
                    'D': np.array([3] * 4, dtype='int32'),
                    'E': ["test", "train", "test", "train"],
                    'F': 'foo'},index=list("abcd"))
#numpy矩阵手动创建
df2 = pd.DataFrame(np.random.randn(10,3), columns = ["ca", "cb", "cc"], index =list("abcdefghij"))

+ + + +

DataFrame对象的属性与方法学习

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
属性描述
columnscolumns属性可以获得dataframe有那些列，即dataframe的index
shapeshape属性是描述dataframe的形状的
sizedataframe的size属性返回的是dataframe的value的个数
values返回当前dataframe的数据和index、columns相对应。
dtypes述当前dataframe的里的每列值的数据类型。
ndim返回数据框维度
Tdataframe的T属性，实际是转置的意思。
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10,3), columns = ["ca", "cb", "cc"], index =list("abcdefghij"))
df.columns
df.index
df.shape
df.size
df.values
df.dtypes
df.ndim
df.T

#方法
df.head()
df.tail(3)
df.to_numpy()
df.describe()  #方法显示数据的快速统计摘要
+ + +

DataFrame数据访问与筛选

需要特别注意的是DataFrame和其他表格数据不一样的是，DataFrame是列访问机制。

+
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
32
33
34
35
import pandas as pd
import numpy as np
val = np.arange(10, 40).reshape(10, 3)
idx = ["ax", "bx", "cx"]
df = pd.DataFrame(val, columns = idx,index=list("abcdefghij"))

#[]号访问列
df["ax"]   #单列索引
df[["ax", "cx"]]  #多列手动选择

#利用列名访问列
df.ax

#DataFrame[start:end]则是通过切片选择的是行。
df["a" : "e"]
df[:3]    #多列切片


###利用方法进行选择

#按位置索引选择：iloc[]行列切片
df.iloc[1] #单独使用选择行
df.iloc[2 : 6, 0 : 2]   #行列选择
df.iloc[[0, 1, 3]]   #不同行选择
df.iloc[[0, 1, 3],[2,1]]   #不同行列选择


#按标签选择  loc[]行列切片， 行列的名字  dataFrame里可以通过loc[]的方式选择label标识的行数据。
df.loc["a"] #单独使用选择行
df.loc[["a","c"]]
df.loc[["a","c"],["ax","cx"]]
df.loc["b" : "e", "bx" : "cx"]
df.loc[: , "bx" : "cx"]


+ +
bool逻辑筛选数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import pandas as pd
import numpy as np
val = np.arange(10, 60).reshape(10, 5)
col = ["ax", "bx", "cx", "dx", "ex"]
idx = list("abcdefghij")
df = pd.DataFrame(val, columns = col, index = idx)

#筛选，bx列大于30的数据
bs = df["bx"] > 30
df[bs]

#组合选择，bx列大于30的数据并且cx列大于40的数据

bs = (df["bx"] > 30) & (df["cx"] > 40)
df[bs]     #选择符合条件的行

#布尔选择的结果还是DataFrame，所以对于结果可以进行切片、label、loc等访问。

+ + +
dataframe数据分类统计（重要）

apply 方法 和 groupby方法对数据进行分类统计

+
1
2
3
4
5
6
7
8
9
10
11
import pandas as pd
import numpy as np
val = np.arange(10, 60).reshape(10, 5)
col = ["ax", "bx", "cx", "dx", "ex"]
idx = list("abcdefghij")
df = pd.DataFrame(val, columns = col, index = idx)

df.apply(lambda col : col.sum(), axis = 0)  #求列的和
df.apply(lambda row : row.sum(), axis = 1)  #求行的和
df["plus"] = df.apply(lambda row : row.ax + row.cx, axis = 1) #两列相加，并增加新列，plus
df
+

groupby 方法，实现分类汇总

+
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
32
import pandas as pd
idx = [101,101,101,102,102,102,103,103,103]
name = ["apple","pearl","orange", "apple","pearl","orange","apple","pearl","orange"]
price = [1.0,2.0,3.0,4.00,5.0,6.0,7.0,8.0,9.0]
df0 = pd.DataFrame({ "fruit": name, "price" : price, "supplier" :idx})

dg =  df0.groupby("fruit")

#批量查看分组结果
for n, g in dg:
    print("group_name:", n, "\n",g,)

#分析结果总结
dg.describe()

#选择需要研究的列,属性或者方法获得统计结果
dg['price'].mean() 
dg['supplier'].value_counts()


#多个分组，大分组之后再分亚组
import pandas as pd
idx = [101,101,101,102,102,102,103,103,103,101,101,101,102,102,102,103,103,103]
name = ["apple","pearl","orange", "apple","pearl","orange","apple","pearl","orange","apple","pearl","orange", "apple","pearl","orange","apple","pearl","orange"]
price = np.arange(18)
df0 = pd.DataFrame({ "fruit": name, "price" : price, "supplier" :idx})

dg2 =  df0.groupby(["fruit", "supplier"])
for n, g in dg2:
    print("multiGroup on:", n, "\n",g)
dg2.describe()

+ +

==groupby方法总结==

+
+

首先通过groupby得到DataFrameGroupBy对象, 然后选择需要研究的列,这样我们就得到了一个SeriesGroupby, 它代表每一个组都有一个Series
对SeriesGroupby进行操作, 比如.mean(), 相当于对每个组的Series求均值

+
+

6.3.4 pandas 应用：读入写出数据处理数据

测试数据：https://archive.ics.uci.edu/ml/machine-learning-databases/iris/

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import os
import pandas as pd
os.chdir("D://python_script//")
fn = "D://python_script//iris.data"
cols_name = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'class']
df = pd.read_csv(fn, names = cols_name)  #更多读取数据：https://pandas.pydata.org/pandas-docs/stable/reference/io.html

data_df=df.iloc[:,0:4]   #筛选一下数据

#利用apply计算：行列的和

data_df.apply(lambda col : col.sum(), axis = 0)
data_df.apply(lambda row : row.sum(), axis = 1)

#自定义计算
data_df["sepal_length x sepal_width"] =data_df.apply(lambda row : row.sepal_width * row.sepal_length, axis = 1)
data_df

data_df.to_csv("out.csv")  #计算结果写出

+ + + + +
+ + + + + + + +
+ + + + + + +
+ + + + +
+ + +
+ + + +
+ + + + + +
+
+ +
+
+ + + + +
+ + © + 2024 + + + + yangzy +
+ + + + + + + + + + + + +
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/archives/2024/06/index.html b/archives/2024/06/index.html index 554e8b9..0f82478 100644 --- a/archives/2024/06/index.html +++ b/archives/2024/06/index.html @@ -159,7 +159,7 @@

Bio_Learning

- 嗯..! 目前共计 3 篇日志。 继续努力。 + 嗯..! 目前共计 6 篇日志。 继续努力。
@@ -299,12 +299,16 @@

Bio_Learning

- 3 + 6 日志
-
+
1 + 分类 +
+
+ 2 标签
diff --git a/archives/2024/07/index.html b/archives/2024/07/index.html new file mode 100644 index 0000000..54e6902 --- /dev/null +++ b/archives/2024/07/index.html @@ -0,0 +1,402 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 归档 | Bio_Learning + + + + + + + + + + + + +
+
+ +
+
+
+
+ + + +
+
+ +
+ + + +

Bio_Learning

+ + +

yang51的学习笔记

+
+ +
+
+
+
+
+ + + + + + + + + +
+
+ + +
+ + 0% +
+ + +
+
+
+ + +
+ + + + + +
+
+
+ 嗯..! 目前共计 6 篇日志。 继续努力。 +
+ + +
+ 2024 +
+ + + + + + + + +
+
+ + + + + + + + +
+ + + + +
+ + +
+ + + +
+ + + + + +
+
+ +
+
+ + + + +
+ + © + 2024 + + + + yangzy +
+ + + + + + + + + + + + +
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/archives/2024/index.html b/archives/2024/index.html index 861daff..ef9cc0e 100644 --- a/archives/2024/index.html +++ b/archives/2024/index.html @@ -159,7 +159,7 @@

Bio_Learning

- 嗯..! 目前共计 3 篇日志。 继续努力。 + 嗯..! 目前共计 6 篇日志。 继续努力。
@@ -167,6 +167,66 @@

Bio_Learning

2024
+ + + + + +
@@ -299,12 +359,16 @@

Bio_Learning

- 3 + 6 日志
-
+
1 + 分类 +
+
+ 2 标签
diff --git a/archives/index.html b/archives/index.html index 55d4091..a727afc 100644 --- a/archives/index.html +++ b/archives/index.html @@ -159,7 +159,7 @@

Bio_Learning

- 嗯..! 目前共计 3 篇日志。 继续努力。 + 嗯..! 目前共计 6 篇日志。 继续努力。
@@ -167,6 +167,66 @@

Bio_Learning

2024
+ + + + + +
@@ -299,12 +359,16 @@

Bio_Learning

- 3 + 6 日志
-
+
1 + 分类 +
+
+ 2 标签
diff --git a/categories/Learn-Python/index.html b/categories/Learn-Python/index.html new file mode 100644 index 0000000..b19f1a5 --- /dev/null +++ b/categories/Learn-Python/index.html @@ -0,0 +1,403 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 分类: Learn_Python | Bio_Learning + + + + + + + + + + + + +
+
+ +
+
+
+
+ + + +
+
+ +
+ + + +

Bio_Learning

+ + +

yang51的学习笔记

+
+ +
+
+
+
+
+ + + + + + + + + +
+
+ + +
+ + 0% +
+ + +
+
+
+ + +
+ + + + + +
+
+
+

Learn_Python + 分类 +

+
+ + +
+ 2024 +
+ + + + + + + +
+
+ + + + + + + + +
+ + + + +
+ + +
+ + + +
+ + + + + +
+
+ +
+
+ + + + +
+ + © + 2024 + + + + yangzy +
+ + + + + + + + + + + + +
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/index.html b/index.html index 054d871..311f5c3 100644 --- a/index.html +++ b/index.html @@ -155,6 +155,2211 @@

Bio_Learning

+
+ + + + + +
+

+ + +

+ +
+ + + + + 发表于 + + + + + + + + + 分类于 + + + + + + + +
+
+ + + + +
+ + + + + + + + + + + + + + + +
imageimageimage
问答社区网站（电脑使用）：http://www.omicsclass.com/组学大讲堂问答小程序(手机使用)组学大讲堂公众号
+
+

Python高级编程

1 函数

1.1 Python内置函数：

Python内置了很多有用的函数，我们可以直接调用。

+

内置函数总结：https://docs.Python.org/zh-cn/3.7/library/functions.html

+
1
2
3
4
5
abs(-100)
max(1, 2)
int('123')
float('12.34')
sum([2,323,23])
+ +

1.2 Python 用户自定义函数

自定义函数：把具有独立功能的代码块组织成为一个小模块。

+

好处：

+
    +
  1. 代码复用，提高编程效率，使程序易于理解。
    2. +
  2. 自己学会定义函数，有助于理解看懂别人函数的帮助
    3. +
+

定义一个函数

你可以定义一个自定义功能的函数，以下是简单的规则：

+
    +
  1. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
    2. +
  2. 括号里面可设置参数，参数不是必必需的(可有可无)，传入参数必须放在圆括号中间。
    3. +
  3. 函数的第一行语句可以选择性地（可有可无）使用文档字符串—用于存放函数使用说明。
    4. +
  4. 函数内容以冒号起始，并且缩进。
    5. +
  5. return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
    6. +
+

参数作用：增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据

+
    +
  1. 在函数内部，把参数当作变量使用，进行需要的数据处理
    2. +
  2. 函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递
    3. +
+

示例

1
2
3
4
5
6
7
8
9
10
11
12
13

#定义
def hello(s):
    '''this function is used to say hello,
    and exit.
    
    '''
    print('hello '+s)
    return
    
#调用
hello(s="omicsgene")

+ + +

不同类型参数的设置与使用

参数根据位置传递

如果我们设置了多个参数，python解释器会根据位置进行传递；

+
1
2
3
4
5
6
7
8
9
10
11
12

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

power(2,3)

power(x=2,n=3)

+ + +
必需参数

直接设定参数，没有给参数的默认值，函数调用时必需给参数传入值

+
1
2
3
4
5
6
7
8
9

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
    
power(4)
+ + + +
设置默认参数(函数调用时可有可无)

设置参数是可以设定参数的默认值，函数调用时可选给参数传入值们不给就是默认值。

+
1
2
3
4
5
6
7
8
9
10
11
12
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

def info(name, gender, age=6, city='Beijing'):
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)
+ + +
可变参数位置参数

* 在参数名字前面加一个星号，使参数成为一个可变参数，参数传入一个列表

+
1
2
3
4
5
6
7
8
def add(a,b):
    return a+b

def add1(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n 
    return sum
+ +
可变关键字参数

** 在参数名字前面加两个星号，使参数成为一个可变关键字参数，参数传入一个字典

+
1
2
3
4
5
6
7
def person(name, age, **kwargs):
    print('name:', name, 'age:', age, 'other:', kwargs)


#联合使用，参数如何传递？  
def foo(a,b,c=22,*args,**kwargs):
    print("a:",a,",","b:",b,",","c:",c,",","args:",args,",","kwargs:",kwargs)
+ +
强制 key=value形式传递

有个参数只有一个星号,表示星号后面的参数必须用（key=value）的形式进行传递参数，不能省略key。

+
1
2
3
4
5
6
7
8
def foo1(a,b,*,c=3):
    print(a,b,c)
    
def foo2(a,b,c=3):
    print(a,b,c)

foo1(1,2,4)
foo2(1,2,4)
+ + +
函数编写与调用注意事项
    +
  1. 必需参数一般写在前面，有默认值的参数紧随其后（位置参数）
    2. +
  2. 参数名省略时，注意位置
    3. +
+
1
2
3
4
def foo(a,b,c=22,*args,**kwargs):
    print(a,b,c,args,kwargs)

foo()
+ + + +

1.3 Python中匿名函数

有时候一个函数只是临时使用一下，以后就不会再使用了，要是用def定义比较麻烦。这个时候就可以用lambda来定义一个匿名函数

+
语法：

变量名= lambda [arg1[, arg2, … argN]]: expression

+
注意:
    +
  1. 参数：可选，通常以逗号分隔的变量表达式形式，也就是位置参数
    2. +
  2. 表达式中不能包含 循环，return
    3. +
  3. 可以包含 if…else…语句.
    4. +
  4. 表达式计算的结果直接返回
    5. +
+
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

# 使用lambda的表达式
lambda x, y: x + y

# 使用def定义的函数
def add( x, y ):
  return x + y

# lambda也允许有默认值和使用变长参数
lambda x, y = 2: x + y
lambda *z: z

# 调用lambda函数
a = lambda x, y: x + y
a(1, 3)

b = lambda x, y = 2: x + y
b(1)

b(1, 3)

c = lambda *z: z
c(10, 'test')


+ + + +

匿名函数应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#自定义排序关键字

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2])            # 按年龄排序
sorted(students, key=lambda s: s[2], reverse=True)       # 按降序


#字典排序：


dic = {'a':2,'b':1}
#按照key排序
d = sorted(dic.items(), key = lambda k:k[0])

#按照values排序
 e = sorted(dic.items(), key = lambda k:k[1])


+

1.4 变量作用域

变量的作用域决定了在哪一部分程序你可以访问那个特定的变量名称。一个程序的所有的变量并不是在任何位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

+

两种最基本的变量作用域如下：

+
    +
  • 全局变量
    • +
  • 局部变量
    • +
+
全局变量和局部变量
    +

  • 定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

    +
    • +

  • 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

    +
    • +
+
1
2
3
4
5
6
7
8
9
10
total = 0; # 这是一个全局变量

def mysum( arg1, arg2 ):
   total = arg1 + arg2; # total在这里是局部变量.
   print("inside  ", total)
   return total
 
#调用mysum函数
mysum( 10, 20 )
print("global var ", total)
+ + +

1.5 变量传递给参数参数的可变性

函数的参数传递中传入可变数据和不可变数据会有不同：

+
    +
  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
    • +
  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
    • +
+
传不可变对象实例,传进去的变量不改变原变量
1
2
3
4
5
6
def ChangeInt(a):
    a = 10
 
b = 2
ChangeInt(b)
print (b) # 结果是 2
+ +
传可变对象实例,传进去的变量可改变原变量
1
2
3
4
5
6
7
8
9
10
def changeme(mylist):
   "修改传入的列表"
   mylist.append([1,2,3,4]);
   print("Inside value:", mylist)
   return
 
# 调用changeme函数
mynum = [10,20,30]
changeme(mynum)
print("Outside value:", mynum)
+ +
+

2 面向对象的编程与获取帮助

2.1 类和实例

+

面向对象最重要的概念就是类（Class）和实例（Instance），类描述了一组具有相同特性（属性）和相同行为（方法）的对象(Object)。面向对象的编程语言最大的特色就是可以编写自己所需的数据类型，以更好的解决问题。

+
+
+

必须牢记类是抽象的模板，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法或者属性，但各自的数据可能不同。

+
+

image

+

面向对象编程特点

面向对象编程(Object-oriented programming，缩写：OOP)的3个基本特征是：封装、继承、多态

+
    +

  • 封装：将属性和方法(数据和功能)封装在一起形成类。

    +
    • +

  • 继承：可以使用现有类的功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

    +
    • +

  • 多态：允许让父类的指针分别指向不同的子类, 调用不同子类的同一个方法, 会有不同的执行效果

    +
    • +
+

2.2 面向对象编程

定义一个类

类的组成
    +
  • 属性(对象的属性) ——变量：状态、静态的
    • +
  • 方法(对象的行为) ——函数：过程、动态的
    • +
+
类的方法与属性
+

在类的内部，使用 def 关键字来定义一个方法，类的方法与普通的函数只有一个特别的区别——他们的第一个参数必须是 self。

+
+
+

self代表类的实例，而非类。

+
+
构造方法

类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用。

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#类的定义
class Car:
    '''this class define a car '''
    #类属性  共有属性
    wheels=4
    #构造方法
    def __init__(self, make, model, year):
        #成员属性
        self.make = make
        self.model = model
        self.year = year
        self.orometer_reading = 0
    #类方法
    def get_description(self):
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model+" "+str(self.wheels)
        return long_name
 
    def get_odometer(self):
        print("This car has "+ str(self.orometer_reading) + " miles on it")
 
    def increase(self,miles):
        self.orometer_reading +=miles

+ +

创建类的实例化对象，访问属性和使用方法

现在让我们新建一个对象my_car:

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#类实例my_car
my_car = Car("yellow", "beetle", 1967)
#查看属性
print(f" My {my_car.color} car {my_car.model} is made in {my_car.year}")

#属性修改
my_car.color="black"

#对象方法调用

my_car.get_description()
my_car.increase(1000)
my_car.read_odometer()
my_car.update_orometer(20000)

#查看类或者实例所有的属性与方法
dir(my_car)
dir(Car)
+

2.3 Python 类定义中的特殊属性与方法

Python中用下划线作为变量前缀和后缀指定特殊变量

+
    +
  • _xxx 不能用’from module import *’导入
    • +
  • __xxx 类中的私有变量名
    • +
  • __xxx__ 系统定义的名字
    • +
  • 核心风格：避免用下划线作为变量名的开始。
    • +
+

因为下划线对解释器有特殊的意义，而且是内建标识符所使用的符号，我们建议程序员避免用下划线作为变量名的开始。

+

==一般来讲，变量名_xxx被看作是“私有的”，在模块或类外不可以使用。==

+

当变量是私有的时候，用_xxx 来表示变量是很好的习惯。因为变量名__xxx__对Python 来说有特殊含义，对于普通的变量应当避免这种命名风格。

+
    +
  • “单下划线” 开始的成员变量叫做保护变量，意思是只有类对象和子类对象自己能访问到这些变量；
    • +
  • “双下划线” 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。
    • +
+
Python类的特殊属性
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
属性含义
__class__对象或类所属的类
__name__类、函数、方法等的名字
__dict__类的属性 以key-value形式展示的字典，展示出属性所对应的值
__module__类定义所在的模块名称
__doc__类、函数的文档字符串，如果没有定义则为None
+
1
2
3
4
5
6
7
8
9
10
11
12
#print(my_car.__name__)
print(my_car.__doc__)
print(my_car.__dict__)
print(my_car.__module__)
print(my_car.__class__)


print(Car.__name__)
print(Car.__doc__)
print(Car.__dict__)
print(Car.__module__)
print(Car.__class__)
+ + + +
Python类特殊方法
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法功能说明
__new__()类的静态方法，用于确定是否创建对象
__init__()构造函数，生成对象时调用
__dir__返回类或者对象的所有方法与属性，dir()操作实例就是调用
__del__()析构函数，释放对象时调用
__add__()+
__sub__()-
__mul__()*
__truediv__()/
__floordiv__()//
__mod__()%
__pow__()**
__repr__()打印,转换
__setitem__()按照索引赋值
__getitem__()按照索引获取值
__len__()计算长度
__call__()函数调用
__contains__()in
__eq__()==
__ne__()!=
__lt__()<
__le__()<==
__gt__()>
__ge__()>=
__str__()转换为字符串
__shift__(), __rshift__()<<, >>
__and__(), __or__()&,
__invert__(), __xor__()~, ^
__iadd__(), __isub__()+=, -=
+
例子：实现特殊方法__repr__：
1
2
3
4
5
6
7
8
9
10
11
12
13

## __repr__
class Person:
    def __init__(self, name):
        self.name = name
    def __repr__(self):
        return "hello %s." % self.name

 p = Person('hkey')

 p
 print(p)

+ +

定义了__repr__方法，不管是直接打印对象还是通过print打印对象，都是走的__repr__中定义的格式。

+

更多类的特殊方法了解：https://www.omicsclass.com/article/1033

+

2.4 类的继承 (选修)

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
#类定义
class people:
    #定义属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    #定义类方法
    def speak(self):
        print("%s speak: I am %d years old." %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s speak: I am %d years old， I am in %d grade of primary school."%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()
+

2.5 Python获取帮助

Python 官方中文帮助

https://docs.Python.org/zh-cn/3.7/

+

编辑器提供帮助

pycharm中的documentation内置显示（默认快捷键为Ctrl+Q），选中函数，Ctrl+Q如下：

+

也有External documetation，快捷键为Shift+F1

+

陌生类获取类的属性和方法

dir()函数主要用来查看对象的属性和方法，再去了解这些属性和方法，学习类的使用。

+

__doc__属性查看帮助文档

任务答案

+
1
2
a = [1,2,3]
a.reverse.__doc__
+ + +

==任务答案：==

+
1
2
3
4
5
6
7
8
9
def my_abs(x):
    a=0
    if x>=0:
        a=x
    else:
        a=0-x
    return a
    
my_abs(-100)
+ + +
+

3 Python 标准库中包的使用

python标准库帮助地址：https://docs.python.org/zh-cn/3.7/library/index.html

+

3.1 包常见导入方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 1 直接导入
import os
import time
import sys
import os,time,sys,re  #每个包之间用逗号隔开；

#导入的同时改名字
import sys as system


#2 导入指定的方法，模块等

#导入包里面的指定的函数或者类
from os import path
from os import path, walk, unlinkfrom

#导入包里面所有的内容
from os import *

+ +

这些导入的包，其实就是别人写好的代码文件(*.py)，我们导入到我们的程序中就可以直接使用里面的方法，函数，类等，省去自己编写代码的麻烦。如果了解Python包导入的机制，自己也可以写一些包，共享给别人，提供代码的复用性，从而提高我们的开发效率。

+

3.2 Python 自定义模块导入讲解

模块搜索路径

导入过程首先需要定位导入文件的位置，也就是，告诉Python到何处去找到要导入的文件，因此，需要设置模块的搜索路径。在大多数情况下，Python会自动到默认的目录下去搜索模块；如果要在默认的目录之外导入模块，就需要知道Pyhon搜索模块路径的机制。

+

Python搜索模块的路径是由四部分构成的：==程序的主目录、PATHONPATH目录、标准链接库目录和.pth文件的目录，这四部分的路径都存储在sys.path 列表中。==

+
1， 程序的主目录

主目录是指程序所在的目录，Python首先会到主目录中搜索模块。

+

因为主目录总是第一个被搜索，如果模块完全处于主目录中，所有的导入都会自动完成，而不需要单独配置路径。

+
2，PATHONPATH目录

PythonPATH目录是指PythonPATH环境变量中配置的目录，是第二个被搜索的目录，Python会从左到右搜索PythonPATH环境变量中设置的所有目录。

+
3，标准链接库目录

标准链接库目录是Python按照标准模块的目录，是在安装Python时自动创建的目录，通常不需要添加到PythonPATH目录中。例如：

+
4，路径文件（.pth文件）

在模块搜索目录中，创建路径文件，后缀名为.pth，该文件每一行都是一个有效的目录。Python会读取路径文件中的内容，每行都作为一个有效的目录，加载到模块搜索路径列表中。简而言之，当路径文件存放到搜索路径中时，其作用和PYT)HONPATH环境变量的作用相同。

+

3.3 导入自定义模块指定路径的方法

方法1：简单不用操作

把自己写的模块，复制到自己的程序同级目录就可以直接导入；

+
方法2: 函数添加 （临时添加）
    +
  1. import sys
    2. +
  2. 查看sys.path
    3. +
  3. 添加sys.path.append(“D:\\perl_script”)
    4. +
+
方法3: 增加.pth文件，推荐！ （永久添加）
    +

  • 在site-packages目录添加一个文件如mypkpath.pth，必须以.pth为后缀，文件内写上你要加入的模块文件所在的路径，可以添加多行。

    +
    • +

  • 如果运行在Windows和Python3.0中，如果Python安装目录的顶层是C:\Users\Administrator\AppData\Local\Programs\Python\Python37，那么可以把自定义的路径文件 mypath.pth 放到该目录中。

    +
    • +

  • 也可以放到标准库所在位置的site-packages子目录中（C:\Users\Administrator\AppData\Local\Programs\Python\Python37\Lib\site-packages），来扩展模块的搜搜路径。

    +
    • +
+
方法4: 修改环境变量 （永久添加）
    +
  • windows用户可以修改系统环境变量 PYTHONPATH
    • +
  • linux用户也可以添加环境变量 PYTHONPATH
    • +
+

练习：

导入自己写的一个模块：

+

把以下内容存储到文件cars.py中，然后用import导入该模块：

+
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

CAR_num=11

make=["Ford","Rolls-royce","Volkswagen"]

def mysum( arg1, arg2 ):
   total = arg1 + arg2; # total在这里是局部变量.
   print("inside  ", total)
   return total;


def das_auto(make="Volkswagen", model="Magotan", year=2019):
    '''this function is used to create Volkswagen car'''
    my_car=Car("Volkswagen","Magotan",2019)
    return my_car


#类的定义
class Car:
    '''this class define a car '''
    #类属性  共有属性
    wheels=4
    #构造方法
    def __init__(self, make, model, year):
        #成员属性
        self.make = make
        self.model = model
        self.year = year
        self.orometer_reading = 0
    #类方法
    def get_description(self):
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model+" "+str(self.wheels)
        return long_name
 
    def read_odometer(self):
        print("This car has "+ str(self.orometer_reading) + " miles on it")
 
    def update_orometer(self,miles):
        if miles >= self.orometer_reading:
            self.orometer_reading = miles
        else:
            print("You can'troll back an odometer")
 
    def increase(self,miles):
        self.orometer_reading +=miles

+ +
==小知识== 模块和包的区别

（1）模块：是一个单独的.py文件，用于存放一些功能相关的代码，可以是代码更加容易维护，提高代码的重用价值

+

（2）包：是一个有层级的目录结构，包含n个模块或者n个子包，包中一定要有__init__.py文件

+

3.4 Python中 os sys time math包的学习

os 常用方法

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法说明
os.getcwd()得到当前工作目录，即当前Python脚本工作的目录路径。
os.mkdir()方法用于以数字权限模式创建目录，
os.listdir(path)返回指定目录下的所有文件和目录名。
os.walk()方法用于通过在目录树中游走输出在目录中的文件名，向上或者向下。
os.remove(path)方法用来删除一个文件。如果指定的路径是一个目录，将抛出OSError，在Unix, Windows中有效
os.rmdir(path)方法用于删除指定路径的目录。仅当这文件夹是空的才可以, 否则, 抛出OSError。
os.system(command)函数用来运行shell命令。
os.linesep字符串给出当前平台使用的行终止符。例如，Windows使用’\r\n’，Linux使用’\n’而Mac使用’\r’。
os.sep可以取代操作系统特定的路径分隔符。windows下为 “\\”,linux 下为”/“
os.chdir(dirname)改变工作目录到dirname
os.path.isfile(path)方法分别检验给出的路径是否一个文件，输入路径必须是绝对路径。
os.path.isdir(path)方法检验给出的路径是否一个目录，输入路径必须绝对路径。
os.path.exists()方法用来检验给出的路径是否真地存在
os.path.join(path,name)连接目录与文件名或目录;使用“\”连接
os.path.basename(path)返回文件名
os.path.dirname(path)返回文件路径
os.path.abspath(name)获得绝对路径
os.path.getsize(name)获得文件大小
os.path.split(path)将path分割成目录和文件名二元组返回。
os.path.splitext()分离文件名与扩展名
+

包使用示例代码

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
#遍历一个目录，获得所有文件的路径

import os  
os.chdir("D:\Python_script")
cwd = os.getcwd()  
for dir_path, dir_names, file_names in os.walk(cwd): 
    for file_name in file_names:    
        p=os.path.join(dir_path,file_name)
        print(p)
    for dir_name in dir_names:
        p=os.path.join(dir_path,dir_name)
        print(p)


#windows系统中调用命令
os.system('copy a.v b.v')
os.system('del b.v')
os.system('rename a.v b.v')


#linux系统中调用命令
os.system('cp a.v b.v')
os.system('rm b.v')
os.system('mv a.v b.v')

+ + +

sys包常用属性或者方法

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法说明
sys.argv命令行参数List，第一个元素是程序本身路径
sys.exit(n)退出程序，正常退出时exit(0)
sys.version获取Python解释程序的版本信息
sys.modules返回系统导入的模块字段，key是模块名，value是模块
sys.path返回模块的搜索路径，初始化时使用PythonPATH环境变量的值
sys.stdout标准输出
sys.stdin标准输入
sys.stderr错误输出
+

math 常用属性和方法

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法说明示例
math.e自然常数e>>> math.e
math.pi圆周率pi>>> math.pi
math.log10(x)返回x的以10为底的对数>>> math.log10(2)
math.pow(x, y)返回x的y次方>>> math.pow(5,3)
math.sqrt(x)返回x的平方根>>> math.sqrt(3)
math.ceil(x)返回不小于x的整数>>> math.ceil(5.2)
math.floor(x)返回不大于x的整数>>> math.floor(5.8)
math.fabs(x)返回x的绝对值>>> math.fabs(-5)
+
+

练习：
将文件打开然后，批量的合并到一个文件中

+
1
2
3
4
5
6
7
8
fw=open("all.fa","w")
for i in os.listdir(os.getcwd()):
    if i.endswith("fa"):
        f=open(i,"r")
        for line in f:
            fw.write(line)
        f.close()
fw.close()
+ + +

4 正则表达式：

4.1 了解正则表达式

正则表达式是用于处理字符串（String）的强大工具，拥有自己独特的语法以及一个独立的处理引擎，效率上可能不如str自带的方法，但功能十分强大。得益于这一点，在提供了正则表达式的语言里，正则表达式的语法都是一样的，区别只在于不同的编程语言实现支持的语法数量不同；

+

正则表达式功能

    +
  • 查找/匹配
    • +
  • 替换
    • +
  • 捕获
    • +
  • 计数
    • +
+

正则表达式通配符

    +
  • 通配符是特殊字符，在正则表达式中有特殊意义
    • +
  • 直接的单词或者数字是原样匹配
    • +
+

常见通配符学习

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
模式匹配通配符描述
^匹配字符串的开头
$匹配字符串的末尾。
.匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[…]用来表示一组字符,单独列出：[amk] 匹配 ‘a’，’m’或’k’，[a-zA-Z0-9]
[^…]不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
\w匹配字母数字及下划线
\W匹配非字母数字及下划线
\s匹配任意空白字符，等价于 [\t\n\r\f].
\S匹配任意非空字符
\d匹配任意数字，等价于 [0-9].
\D匹配任意非数字
*匹配0个或多个的表达式,如:be*: b, be,beeeee, bee。
+匹配1个或多个的表达式,如: be+ : be,beeeee, bee。
?匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式 .如 bo? 只能匹配：b,bo
{ n}精确匹配 n 个前面表达式。例如， o{2} 不能匹配 “Bob” 中的 “o”，但是能匹配 “food” 中的两个 o。
{ n,}匹配 n 个前面表达式。例如， o{2,} 不能匹配”Bob”中的”o”，但能匹配 “foooood”中的所有 o。”o{1,}” 等价于 “o+”。”o{0,}” 则等价于 “o*”。
{ n, m}匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
|或者的意思，如：a| b 匹配a或b
()对正则表达式分组并记住匹配的文本,正则表达式捕获功能
+
选修内容
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
模式匹配通配符描述
(?imx)正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)类似 (…), 但是不表示一个组
(?imx: re)在括号中使用i, m, 或 x 可选标志
(?-imx: re)在括号中不使用i, m, 或 x 可选标志
(?#…)注释.
(?= re)前向肯定界定符。如果所含正则表达式，以 … 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)匹配的独立模式，省去回溯。
\A匹配字符串开始
\Z匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z匹配字符串结束
\G匹配最后匹配完成的位置。
\b匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配”never” 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。
\B匹配非单词边界。’er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。
\n, \t, 等.匹配一个换行符。匹配一个制表符。等
\1…\9匹配第n个分组的内容。
\10匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。
+

4.2 正则表达式实操学习

https://regexone.com/

+

正则表达式练习

    +
  • 应用 notepad++ 或者editplus 软件 正则表达式处理文本
    • +
  • 不足之处->无法处理大文件（内存限制）
    • +
+
练习要求：
    +
  • 处理要求1：把序列转换成一行；
    • +
  • 处理要求2：把一行的序列文件再转换回来；
    • +
+

处理文件内容示例：

+
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
32
33
34
35
36
37
>NP_651973.4 nbs, isoform E [Drosophila melanogaster]
MFVLTKDDEKFVLFPGKKVYTIGRLATDLIVAQDLSISRNHAQLLIQTEADGDDTLHIEDLGSRYGTFIF
PKNSQKPRKVPAKTSTPLPVGTRLRFGANMSIWQVTQLKLVTTVSALTRSEVQELTKMLEPMGGTVTSNW
TEECSHLTMNEVSVTVKLLHAMLENKPIVTFPYWRKMLQAAQSIHVKEGWPQPEDYQPTNIDVTWRPERT
RLFAGKTFVFMNRKHFDMYGSVVQKAGATCKDINSGVRKTFLTKSDVIVIQYVPSSQSQATESINSIQDR
YILEQNGRRIIQEYEIGMALIHCSITEFCNPTHKFISDSLPTTESVTSSMAFNSSIIVPNTERHSAQSNA
TPISELVVPESIECEMEQDASKPHSEDQASLRKRSHASTVDSSDEEKKSTLSKRAKSDIATKLTMKSKNA
ILLDSSLEEDVTPAPAPAPVQRVTRQSKAIAEEKSVHPPVPAASKHITRKTKQVFCVDSSDEENENARKP
KETPAPTIPSMAKKKTEAPVATRISPRLNGKSLATNITNQPADKHAVPAKRPVLSVASSDEEDEGDLFQF
RKSPQKPAETVVQPRIAGKGNAPARISVVDFLEKSQAQEPAPVPPQLESQSQTQPRKRLRLELLNESDSD
DCDNLFNFADSKKKRKTQEAQRNDDSTDGLFNFNSERPSDHDDEDSRLTEPFVPETESKKQSKYIVAPRR
DRPKKVDISGWLSCSRLNDNIKSEIDADSVKMETSIKADPDEEQWLAAMKDSIEVRMCNLNIVIRSQEEV
DASLEDSVNKHGGRKNFKKFVKTKNPHPQKRIVALKSLRLADGMVTCV

>AIQ85043.1 NBS-LRR disease resistance protein, partial [Musa ABB Group]
MGGVGKTTLAQQAYNPERVKDYFHHKVWVCVSDNFNVERLSKEIIESITENKCDLSNLDTLQVVVKKKLT
SKRFLLVLDDVWNEDSLKWERFCAPLRYGEPGSKILVTTRSKKIAEMVGNPFPLGGLDEASYWKLFKKCA
FGSEYAGE

>AIQ85044.1 NBS-LRR disease resistance protein, partial [Musa laterita]
GGGGKTSLAQQAYNHERVKDYFHHKVWVCVSDNFNVERLTKEIIESLTRNKWDLNNLDTLQVVVKEELTS
KRFLLVLDDVWNEDSLKWERFCAPLRYGEPGSKILVTTRSKKIAEMVGNPIPLGGLDEASYWELFKKCAF
GSEDAGE

>AIQ85045.1 NBS-LRR disease resistance protein, partial [Musa laterita]
MGGVGKTTLAQQAYNHERVQDYFQHEVWVCVSDNFNVERLTKEIIESITENKCDLSNLDTLQVVLKKNLT
SKRFLLVLDDVWNEDSLKWERFCAPLRYGEPGSKILVTTRSKNVFENGWNPIPLGGLDEASYWKLFKKCA
FGSEDAGEFPHLE

>AAM28915.1 NBS, partial [Pinus taeda]
TRFDWKEQLHRLQHVLPSETQEKLXFGYLNLNREERQMFLDSACFFIGQKRDTAIRIWEGSLWDGHSGFL
TLQHRCLLGVDDENNIEXHDHLRDFGRAACPNRFLPSWIPMDSLRVLQVSGSVLKTLWEDDSQPPLQLRE
LEINAPLSNIPGSIGRLKHLERFVVGKYLSGQVNLTELPVEFCHLQSLKALVLTECSKIKSLPEFGALLM
WLRHIDLSFCRNLERLPDSLHYLSHLRLINLSDCHDLVTLPDNIGRLRCLQHIDLQGCHNLERLPDSFGE
LTDLRHINLSGCHDLQRLPDSFGKLRYLQHIDLHGCHSLEGLPISFGDLMNLEYINLSNCHNLERLPESI
GNLSDLRHIDLSGCHNLERLPDNFRELEELRYLDVEGCSNLIIDRFEIIGISDNLPVAHQVNWNKY

+ +

4.3 Python中正则表达式re包

==新包学习思路总结：==

+
    +
  1. 学习里面的函数/方法
    2. +
  2. 类实例化后对象的学习(方法，属性)
    3. +
  3. 都有哪些类，类之间的关系
    4. +
+

re包中常用方法

    +
  1. re.search(pattern, string, flags=0)
    2. +
  2. re.match(pattern, string, flags=0)
    3. +
  3. re.findall(pattern, string, flags=0)
    4. +
+

参数说明

+
    +
  • pattern 匹配的正则表达式
    • +
  • string 要匹配的字符串。
    • +
  • flags 用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。见：正则表达式修饰符
    • +
+

注意区别：

re.match与re.search的区别
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

+

re.match和re.search 与findall的区别：
前面两个找到一个就结束，findall会找到所有。
返回对象不同，findall返回列表，

+

正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
修饰符描述
re.I忽略大小写
re.M多行匹配，影响 ^ 和 $
re.U根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.L做本地化识别（locale-aware）匹配
re.S使 . 匹配包括换行在内的所有字符
re.X该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
+

代码示例：

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import re
 
line = "Cats are smarter than dogs"
 
matchObj = re.match( r'dogs', line, re.I)
if matchObj:
   print("match --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")


line = "Cats are smarter than Dogs"
matchObj = re.search( r'dogs', line, re.I)
if matchObj:
   print ("search --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")
+ + + +

匹配对象的方法 得到详细的搜索匹配结果

    +
  • group() 返回被 RE 匹配的字符串。
    • +
  • start() 返回匹配开始的位置
    • +
  • end() 返回匹配结束的位置
    • +
  • span() 返回一个元组包含匹配 (开始,结束) 的位置
    • +
+

更多方法及帮助：https://docs.python.org/zh-cn/3.7/library/re.html#match-objects

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import re


line = "Cats are smarter than dogs";
 
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
 
if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"
   
   
print(re.search('www', 'www.omicsclass.com').span())  # 在起始位置匹配
print(re.search('com', 'www.omicsclass.com').span())         # 不在起始位置匹配
+ + +

搜索替换

Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。支持正则表达式，比字符串自带的replace方法功能更强大。

+

语法：

+
+

re.sub(pattern, repl, string, count=0, flags=0)

+
+
    +
  • pattern : 正则中的模式字符串。 (搜索的内容)
    • +
  • repl : 替换的字符串，也可为一个函数。 (替换的内容)
    • +
  • string : 要被查找替换的原始字符串。 (在哪里搜索替换)
    • +
  • count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
    • +
  • flags 用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。见：正则表达式修饰符
    • +
+
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
import re
 
tel = "010-8054-3251,www.omicsclasss.com"

# 删除字符串中的 数字 
num = re.sub(r"^\d+-\d+-\d+,", "", tel)
print("Website is:", num)
 
# 删除数字
num = re.sub(r'\d+', "", tel)
print("telphone num : ", num)



### 高级用法 （选修）
#repl 参数是一个函数
#以下实例中将字符串中的匹配的数字乘以 2：

# 将匹配的数字乘以 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
 
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))
+

re.split 方法支持正则表达式：

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：

+
+

re.split(pattern, string[, maxsplit=0, flags=0])

+
+
    +
  • pattern 匹配的正则表达式
    • +
  • string 要分割的字符串。
    • +
  • maxsplit 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
    • +
  • flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
    • +
+
1
2
3
4
5
6
7
8
9
import re
re.split(r'[,;=]', 'omicsclass, omicsclass;omicsclass.')
re.split(r'\s+', ' omicsclass, omicsclass, omicsclass.') 
re.split(r',', ' omicsclass, omicsclass, omicsclass.', 1) 

 
re.split(r'\t', 'hello world')   # 对于一个找不到匹配的字符串而言，split 不会对其作出分割
['hello world']

+ + +

re.compile 方法

compile 方法用于编译正则表达式，提前编译后的正则表达式可以加快正则表示的匹配速度；编译后生成一个正则表达式（ Pattern ）对象。

+

语法格式为：

+
+

re.compile(pattern[, flags])

+
+
    +
  • pattern : 一个字符串形式的正则表达式
    • +
  • flags 用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。见：正则表达式修饰符
    • +
+
Pattern正则表达式对象 （正则对象）

常见方法：

+
    +
  • Pattern.findall(string[, pos[, endpos]])
    • +
  • Pattern.search(string[, pos[, endpos]])
    • +
  • Pattern.match(string[, pos[, endpos]])
    • +
+

参数：

+
    +
  • string : 待匹配的字符串。
    • +
  • pos : 可选参数，指定字符串的起始位置，默认为 0。
    • +
  • endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。
    • +
+

注意： match 和 search 是匹配一次 findall 匹配所有。

+

更多方法：https://docs.python.org/zh-cn/3.7/library/re.html#regular-expression-objects

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import re
 
p = re.compile(r'\d+')   # 查找数字
result1 = p.findall('omicsclass 123 google 456')
result2 = p.findall('runomicsclass123google456', 0, 10)
 
print(result1)
print(result2)



result3=p.search("runomicsclass123google456")
result4=p.match("runomicsclass123google456")

print(result3)
print(result4)

#或者也可以这样用
result5=re.search(p,"runomicsclass123google456")
result6=re.match(p,"runomicsclass123google456")

print(result5)
print(result6)
+ + + +

正则表达式处理文件主要用处

    +
  1. split分隔文件
    2. +
  2. 查找是否含有某某字符，配合IF判断
    3. +
  3. 在字符串中捕获信息
    4. +
+

练习

从GFF文件中提取基因ID及位置信息存成表格(注意用正则表达式的捕获功能完成)

+

GFF 文件（人1号染色体上基因注释信息）地址：ftp://ftp.ensembl.org/pub/release-98/gff3/homo_sapiens/Homo_sapiens.GRCh38.98.chromosome.1.gff3.gz

+

答案：

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import re

fr=open("D:\\python_script\\Homo_sapiens.GRCh38.98.chromosome.1.gff3\\Homo_sapiens.GRCh38.98.chromosome.1.gff3","r")

fw=open("D:\\python_script\\chr1.txt","w")

for line in fr:
    if re.match("#",line):
        continue
        
    tmp=re.split("\t",line)
    if tmp[2] == "gene":
        mobj=re.search("ID=gene:([^;]+)",tmp[8]) #捕获基因ID
        if mobj:
            fw.write("\t".join([tmp[0],tmp[3],tmp[4],tmp[6],mobj.group(1)])+"\n")
            
fr.close()
fw.close()
+ + +
+

5 Python biopython包处理生物数据

5.1 BioPython包

image

+

专门用于处理生物数据的包，主要功能如下：

+

（1）biopython处理生物数据

    +
  • Blast output – both from standalone and WWW Blast
    • +
  • Clustalw
    • +
  • FASTA/FASTQ
    • +
  • GenBank
    • +
  • PubMed and Medline
    • +
  • ExPASy files, like Enzyme and Prosite
    • +
  • SCOP, including ‘dom’ and ‘lin’ files
    • +
  • UniGene
    • +
  • SwissProt
    • +
+

（2）在线链接生物数据库，实时处理数据

    +
  • NCBI – Blast, Entrez and PubMed services
    • +
  • ExPASy – Swiss-Prot and Prosite entries, as well as Prosite searches
    • +
+

（3）与生物信息常用软件交户，实现批量处理分析数据

    +
  • Standalone Blast from NCBI
    • +
  • Clustalw alignment program
    • +
  • EMBOSS command line tools
    • +
+

获取帮助：

官方网站：https://biopython.org/

+

帮助文档：http://biopython.org/DIST/docs/tutorial/Tutorial.pdf

+

中文帮助文档（Last Update – 22 March 2013 (Biopython 1.61+)）：https://biopython-cn.readthedocs.io/zh_CN/latest/

+

安装

1
2
3
4
5
6
pip install biopython -i  https://pypi.tuna.tsinghua.edu.cn/simple #安装
pip install --upgrade biopython  #更新
pip uninstall biopython  #卸载

#导入包：
import Bio
+

5.2 利用biopython处理序列(fasta，fastq等)

Seq序列对象与SeqRecord注释对象学习

Seq对象中文帮助： https://biopython-cn.readthedocs.io/zh_CN/latest/cn/chr03.html#chapter-bio-seq

+

SeqRecord注释对象中文帮助： https://biopython-cn.readthedocs.io/zh_CN/latest/cn/chr04.html#chapter-seqrecord

+

5.2.1 Seq序列对象

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
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio.Alphabet import IUPAC
from Bio.SeqUtils import GC

#Seq 对象创建
dna_seq = Seq("AGTACACTGGT", IUPAC.unambiguous_dna)
protein_seq = Seq("EVRNAK", IUPAC.protein)

#序列对象继承了字符串对象一些方法
len(dna_seq)
dna_seq.count("A")
GC(dna_seq)  #计算GC含量
dna_seq[4:12] #切取序列
str(dna_seq)  #将序列对象转换成字符串
my_seq = Seq("ACGT", IUPAC.unambiguous_dna)
my_seq + dna_seq  #连接或添加序列
my_seq.upper()  
my_seq.lower()

#核苷酸序列反向互补序列            
my_seq.reverse_complement()  

#转录
coding_dna = Seq("ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG", IUPAC.unambiguous_dna)
messenger_rna = coding_dna.transcribe()
messenger_rna.back_transcribe()  #从mRNA逆向转录为DNA编码链的方法

#翻译  https://biopython-cn.readthedocs.io/zh_CN/latest/cn/chr03.html#sec-translation
coding_dna.translate()

+ + +

Bio.Alphabet.IUPAC 提供了蛋白质、DNA和RNA的基本定义：

+
    +
  • IUPAC.protein 蛋白质
    • +
  • IUPAC.unambiguous_dna DNA
    • +
+

更多编码见：https://www.omicsclass.com/article/409

+

5.2.2 SeqRecord序列注释对象

SeqRecord 类非常简单,包括下列属性:

+

.seq
– 序列自身（即 Seq 对象）。

+

.id
– 序列主ID（-字符串类型）。通常类同于accession number。

+

.description
– 序列描述（-字符串类型）。

+

.name
– 序列名/id （-字符串类型）。 可以是accession number, 也可是clone名（类似GenBank record中的LOCUS id）。

+

.letter_annotations
– 对照序列的每个字母逐字注释（per-letter-annotations），以信息名为键（keys），信息内容为值（value）所构成的字典。值与序列等长，用Python列表、元组或字符串表示。.letter_annotations可用于质量分数(如第 18.1.6 节) 或二级结构信息 (如 Stockholm/PFAM 比对文件)等数据的存储。

+

.annotations
– 用于储存附加信息的字典。信息名为键（keys），信息内容为值（value）。用于保存序列的零散信息（如unstructured information）。

+

.features
– SeqFeature 对象列表，储存序列的结构化信息（structured information），如：基因位置, 蛋白结构域。

+

.dbxrefs
– 储存数据库交叉引用信息（cross-references）的字符串列表。

+

SeqRecord对象创建

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
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio.Alphabet import IUPAC

simple_seq = Seq("CCCTTCTTGTCTTCAGCGTTTCTCC", IUPAC.unambiguous_dna)
simple_seq_r = SeqRecord(simple_seq, id="AC12345",description="just a test sequence")

#属性后添加和修改
simple_seq_r.description = "just a test sequence"

simple_seq_r.seq
simple_seq_r.id
simple_seq_r.description

#如果是fastq文件，可以添加序列质量值注释信息

simple_seq_r.letter_annotations["phred_quality"] = [26, 26, 18, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 22, 26, 26, 26, 26,
26, 26, 26, 23, 23]
print(simple_seq_r.letter_annotations)
print(simple_seq_r.letter_annotations["phred_quality"])


#序列截取：

simple_seq_r[0:2]

+ +

SeqRecord对象从文件中获得

fasta/fastq文件读写，得到SeqRecord对象；

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#fasta文件读取得到SeqRecord对象
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os

os.chdir("D:\\python_script")
output_handle = open("out.fa", "w")
for rec in SeqIO.parse("test.fa", "fasta"):
    seq=rec.seq
    seq_r = SeqRecord(seq[0:10],id=rec.id,description=rec.description)
    SeqIO.write(seq_r, output_handle, "fasta")

output_handle.close()
+

5.3 练习

任务：利用biopython处理fasta/fastq序列
    +
  1. 任务: 提取指定ID的fasta序列
    2. +
  2. 任务: 截取fasta序列中指定位置的序列
    3. +
  3. 任务: fastq文件转换成fasta文件
    4. +
  4. 任务: fastq文件去掉前5个碱基
    5. +
+

fa文件：

+
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
>AT1G66550.1 cds chromosome:TAIR10:1:24828537:24829589:1 gene:AT1G66550 gene_biotype:protein_coding transcript_biotype:protein_coding gene_symbol:WRKY67 description:Probable WRKY transcription factor 67 [Source:UniProtKB/Swiss-Prot;Acc:Q93WV7]
ATGGTTTCCAACATTGATCACAAGGCTATGGAAGCACTCCTCCGTGGCCAAGGATGCGCT
AACAACCTCAAGATTCTCCTTGAAAACGGCGAAATAAGCTCAGTTTCAACAGAACCACTC
ATCCACACCATTCTCGATTCTTTCTCACTTGCTCTGTCTTTTATGGATTCTCCTAATCAT
CCACCATACCATGAATCCTCTTCTCATAACATGGCAAGTCATATGTCCCGGAGATCATCT
AAGCAAGTACAACATCGCAGAAAACTTTGTGTAGCAGAAGGTTTAGTGAATTACAATCAC
GATTCCCGGACTATGTGCCCCAATGATGGCTTCACCTGGAGGAAATATGGACAAAAAACC
ATTAAAGCCTCAGCGCACAAAAGGTGTTACTATCGGTGTACCTATGCAAAAGACCAAAAC
TGCAATGCTACAAAGCGGGTGCAGAAGATCAAAGACAACCCTCCAGTGTACAGAACCACT
TACTTGGGAAAACATGTGTGTAAAGCTTTTGCAGTTCATGATGATACATATAGTTCCACG
ATGATTCGATTCGACCAAGTTGTTCCTGAACCGATTATGCCGCAGCTCACAACAATTGAC
CACCAAGTAATTACCGTGGAGGAAAACTCCGCAGAACATATCATGAACCAAGAATGTGAT
ATTAATGATTATTTGGTGGATGATGACCCATTTTGGGCTAGTCAATTTCCCCCGTTTCCA
TCGAGTGACACAATGTTCTTGGAAAACATTTCTGCTTTTGATTAG
>AT4G39410.1 cds chromosome:TAIR10:4:18332606:18334893:-1 gene:AT4G39410 gene_biotype:protein_coding transcript_biotype:protein_coding gene_symbol:WRKY13 description:WRKY13 [Source:UniProtKB/TrEMBL;Acc:A0A178UV80]
ATGGGTGCGATAAACCAAGGAATAAGCTTGTTTGATGAATCACAAACCGTCATAAACCCT
ATTAATACCAACCATCTAGGTTTCTTCTTCTCTTTCCCTAGTCACAGCACCTTATCTTCA
TCATCTTCGTCGTCTTCGTCTTCTCCTTCTTCTCTTGTGTCTCCATTTCTTGGTCATAAC
TCCCTAAACTCCTTCCTTCATAATAACCCGTCTTCATTCATAAGTCATCCTCAAGATTCC
ATCAATCTCATGACCAATCTCCCCGAAACCCTAATCTCGTCTTTGTCCTCATCAAAGCAA
AGGGACGATCATGATGGTTTTCTTAATCTCGATCATCATCGTCTTACCGGTAGTATTTCA
TCCCAAAGACCCCTGTCAAATCCATGGGCATGGAGTTGTCAAGCGGGATACGGAAGCAGC
CAGAAAAACAACCATGGAAGCGAGATTGATGTTGATGATAATGATGATGAGGTTGGCGAT
GGTGGTGGCATTAATGATGATGATAATGGTCGTCATCATCATCATGATACTCCCAGTCGT
CATGATAAACATAACACAGCGTCATTAGGCGTAGTTTCTTCTCTGAAGATGAAGAAGCTT
AAGACAAGAAGAAAAGTGAGGGAACCTCGGTTTTGCTTTAAGACACTTAGCGAGGTTGAT
GTCTTAGATGATGGATATAGATGGAGAAAGTATGGCCAGAAAGTTGTCAAAAACACCCAA
CATCCCAGGAGCTATTACAGATGCACACAAGACAAGTGTAGAGTGAAGAAGAGAGTGGAG
AGATTAGCAGATGACCCAAGAATGGTAATCACTACTTACGAAGGAAGACACCTTCACTCT
CCTTCTAATCATCTCGACGACGACTCTCTCTCCACCTCTCACCTGCACCCTCCTCTCTCC
AACTTCTTCTGGTGA
>AT4G18170.1 cds chromosome:TAIR10:4:10061214:10062893:1 gene:AT4G18170 gene_biotype:protein_coding transcript_biotype:protein_coding gene_symbol:WRKY28 description:WRKY28 [Source:UniProtKB/TrEMBL;Acc:A0A178V3M3]
ATGTCTAATGAAACCAGAGATCTCTACAACTACCAATACCCTTCATCGTTTTCGTTGCAC
GAAATGATGAATCTGCCTACTTCAAATCCATCTTCTTATGGAAACCTCCCATCACAAAAC
GGTTTTAATCCATCTACTTATTCCTTCACCGATTGTCTCCAAAGTTCTCCAGCAGCGTAT
GAATCTCTACTTCAGAAAACTTTTGGTCTTTCTCCCTCTTCCTCAGAGGTTTTCAATTCT
TCGATCGATCAAGAACCGAACCGTGATGTTACTAATGACGTAATCAATGGTGGTGCATGC
AACGAGACTGAAACTAGGGTTTCTCCTTCTAATTCTTCCTCTAGTGAGGCTGATCACCCC
GGTGAAGATTCCGGTAAGAGCCGGAGGAAACGAGAGTTAGTCGGTGAAGAAGATCAAATT
TCCAAAAAAGTTGGGAAAACGAAAAAGACTGAGGTGAAGAAACAAAGAGAGCCACGAGTC
TCGTTTATGACTAAAAGTGAAGTTGATCATCTTGAAGATGGTTATAGATGGAGAAAATAC
GGCCAAAAGGCTGTAAAAAATAGCCCTTATCCAAGGAGTTACTATAGATGTACAACACAA
AAGTGCAACGTGAAGAAACGAGTGGAGAGATCGTTCCAAGATCCAACGGTTGTGATTACA
ACTTACGAGGGTCAACACAACCACCCGATTCCGACTAATCTTCGAGGAAGTTCTGCCGCG
GCTGCTATGTTCTCCGCAGACCTCATGACTCCAAGAAGCTTTGCACATGATATGTTTAGG
ACGGCAGCTTATACTAACGGCGGTTCTGTGGCGGCGGCTTTGGATTATGGATATGGACAA
AGTGGTTATGGTAGTGTGAATTCAAACCCTAGTTCTCACCAAGTGTATCATCAAGGGGGT
GAGTATGAGCTCTTGAGGGAGATTTTTCCTTCAATTTTCTTTAAGCAAGAGCCTTGA
>AT5G45050.1 cds chromosome:TAIR10:5:18176914:18181973:-1 gene:AT5G45050 gene_biotype:protein_coding transcript_biotype:protein_coding gene_symbol:RRS1B description:Probable WRKY transcription factor 16 [Source:UniProtKB/Swiss-Prot;Acc:Q9FL92]
ATGACCGAGAGTGAGCAAATCGTCTACATCAGCTGCATAGAGGAGGTACGATACTCCTTC
GTCAGCCACCTCTCCAAAGCTCTCCAGCGAAAAGGTGTAAACGATGTCTTCATCGATAGC
GATGATTCGCTTTCCAACGAGTCTCAATCAATGGTCGAGAGAGCTAGGGTTTCTGTTATG
ATTTTACCAGGAAACCGTACGGTATCTCTTGACAAGCTCGTGAAGGTTCTCGATTGCCAG
AAGAACAAAGATCAAGTGGTGGTTCCGGTGTTGTACGGTGTCAGATCATCAGAGACCGAA
TGGCTTAGCGCGCTGGATTCGAAAGGATTCTCATCAGTACACCATTCCAGGAAAGAATGT
AGTGACTCCCAGCTTGTAAAAGAGACTGTTAGAGATGTGTATGAGAAGCTCTTTTATATG
GAACGAATTGGAATATATTCGAAGCTGCTGGAGATTGAGAAAATGATTAACAAGCAACCG
TTGGACATCCGTTGTGTTGGAATTTGGGGTATGCCTGGCATAGGCAAGACTACACTTGCT
AAAGCAGTCTTTGACCAAATGTCTGGTGAGTTTGATGCTCATTGCTTTATTGAAGACTAC
ACCAAAGCTATTCAAGAGAAGGGTGTTTATTGTTTGCTGGAGGAACAGTTTTTGAAAGAA
AATGCTGGTGCTAGTGGTACCGTTACGAAATTGAGCTTGCTTAGGGATAGATTAAACAAT
AAGAGGGTTCTTGTTGTTCTTGATGATGTCCGCAGTCCTCTGGTTGTGGAGTCTTTTCTT
GGAGGGTTTGACTGGTTTGGTCCCAAAAGTCTAATCATCATAACCTCCAAAGATAAATCG
GTGTTTCGCCTTTGTCGAGTCAATCAAATATACGAGGTTCAGGGTTTAAATGAGAAAGAG
GCTCTTCAACTCTTCTCTTTGTGTGCGTCTATAGACGATATGGCAGAGCAGAATCTCCAC
GAGGTGTCAATGAAAGTTATTAAATATGCTAATGGCCATCCATTAGCTCTCAATCTCTAT
GGCAGAGAACTGATGGGGAAGAAAAGACCACCAGAAATGGAGATAGCATTCCTCAAACTC
AAGGAATGTCCTCCAGCTATTTTTGTTGATGCAATCAAGAGCTCGTATGACACACTCAAT
GACAGGGAAAAAAACATTTTTTTGGACATAGCTTGTTTCTTCCAGGGAGAAAATGTTGAC
TACGTGATGCAACTGCTTGAGGGTTGTGGTTTCTTTCCACATGTTGGAATTGATGTTCTT
GTGGAGAAGAGTCTGGTGACTATTTCAGAAAACCGAGTGCGGATGCATAACTTGATCCAA
GATGTTGGCCGACAAATAATAAATAGAGAAACAAGACAGACTAAGAGGCGCAGCAGACTG
TGGGAACCTTGCAGCATCAAATATTTATTAGAAGATAAGGAACAAAACGAAAATGAAGAA
CAAAAAACAACTTTTGAACGTGCTCAGGTCCCTGAAGAGATCGAAGGCATGTTTCTGGAC
ACATCAAACTTAAGTTTTGATATTAAGCATGTTGCCTTTGATAATATGTTGAACCTTAGA
TTGTTCAAGATTTACAGTTCCAATCCTGAAGTCCATCATGTAAACAATTTCCTCAAAGGC
TCTCTCAGTTCTCTTCCTAATGTGCTAAGACTCCTGCATTGGGAGAACTATCCTCTGCAG
TTTCTGCCTCAAAATTTTGATCCTATACACCTTGTTGAAATCAACATGCCGTACAGCCAA
CTTAAGAAACTTTGGGGTGGAACCAAGGACCTGGAGATGTTGAAGACAATCAGGCTTTGT
CATTCCCAACAACTAGTTGATATTGACGATCTTTTAAAAGCTCAAAATCTTGAGGTAGTT
GATCTCCAAGGCTGTACAAGACTGCAGAGTTTCCCAGCCACCGGTCAATTGCTACATTTA
CGAGTTGTAAATCTCTCAGGTTGCACAGAGATCAAAAGTTTCCCAGAAATTCCCCCAAAT
ATTGAGACACTGAATCTACAGGGGACTGGTATAATAGAATTACCACTTTCCATTGTTAAG
CCAAACTACAGAGAGCTTTTGAATCTTCTAGCTGAAATCCCGGGTCTTTCAGGTGTCTCA
AACCTTGAGCAAAGTGATCTCAAACCTTTAACAAGCCTGATGAAAATTAGCACATCTTAC
CAAAATCCTGGCAAGCTTAGTTGCTTGGAGCTGAATGATTGTTCTCGTTTGCGAAGTCTG
CCAAACATGGTTAATTTAGAACTTCTCAAAGCCCTTGATCTTTCTGGTTGCTCAGAGCTC
GAGACTATCCAGGGTTTCCCACGGAACCTGAAAGAGTTATATCTTGTTGGCACTGCAGTA
AGACAAGTGCCACAACTTCCTCAAAGTCTAGAATTCTTTAATGCCCATGGTTGTGTCTCT
CTCAAATCAATTCGTTTGGACTTCAAGAAGCTTCCTGTGCATTACACATTTAGTAATTGT
TTCGATCTATCTCCACAAGTGGTCAACGATTTTTTAGTGCAGGCGATGGCTAATGTGATT
GCAAAACACATACCAAGAGAGCGTCATGTCACAGGCTTTTCTCAAAAGACTGTGCAGCGT
TCGAGTCGTGACAGTCAGCAGGAACTCAACAAAACTTTGGCTTTCAGCTTCTGTGCGCCC
TCACATGCGAATCAAAATTCCAAACTTGATCTGCAACCAGGATCTTCTTCAATGACACGA
CTAGATCCTTCTTGGAGGAACACACTTGTGGGCTTTGCTATGCTGGTGCAAGTCGCATTT
TCCGAGGGTTACTGTGATGATACTGATTTTGGCATTAGTTGTGTTTGCAAATGGAAAAAC
AAGGAAGGCCACTCTCATAGGAGAGAAATAAATTTGCATTGTTGGGCTTTAGGGAAAGCT
GTTGAAAGGGATCATACGTTTGTCTTCTTTGATGTCAACATGCGTCCAGATACCGATGAA
GGAAATGACCCCGATATCTGGGCTGATTTAGTTGTTTTTGAGTTCTTTCCTGTCAATAAA
CAGAGAAAGCCTCTAAATGATAGTTGCACAGTGACAAGATGTGGAGTCCGTTTAATAACT
GCTGTAAACTGCAATACAAGTATCGAGAATATATCACCAGTTTTGTCCTTGGATCCGATG
GAGGTTTCTGGTAATGAAGATGAAGAAGTATTGAGAGTCAGATATGCTGGTTTACAGGAG
ATATATAAAGCTTTGTTTCTTTACATAGCGGGTTTGTTCAATGACGAGGATGTTGGTTTG
GTAGCACCACTTATTGCTAACATTATTGACATGGACGTTAGTTATGGGCTCAAGGTCTTA
GCCTATAGGTCTCTCATACGTGTATCTTCCAATGGGGAAATAGTGATGCACTATTTGCTA
CGACAAATGGGTAAAGAAATCCTCCATACAGAATCAAAGAAGACTGACAAATTAGTCGAC
AATATTCAGAGTTCCATGATCGCAACAAAGGAAATCGAGATCACTCGTTCAAAGAGTCGC
CGAAAGAACAACAAGGAAAAGAGAGTGGTTTGCGTAGTGGATCGAGGCAGCCGGTCCAGT
GACCTATGGGTTTGGCGAAAGTATGGTCAAAAACCCATCAAAAGTTCTCCTTATCCAAGG
AGTTACTATAGATGTGCCAGCTCGAAAGGTTGTTTTGCTAGGAAACAAGTCGAACGTAGC
CGCACTGATCCAAATGTTTCAGTAATTACTTACATCTCTGAGCATAACCATCCATTCCCC
ACTCTACGCAATACTCTTGCCGGCTCCACTCGTTCCTCTTCCTCCAAATGCTCAGATGTA
ACTACTTCTGCCTCATCGACAGTCTCCCAAGACAAAGAAGGACCGGATAAATCCCATTTG
CCTTCCTCCCCTGCTTCTCCTCCTTATGCGGCCATGGTGGTTAAGGAGGAGGACATGGAG
CAATGGGACAATATGGAGTTCGATGTTGACGTTGAAGAAGATACTTTCATACCCGAATTA
TTTCCAGAGGATACCTTCGCTGATATGGACAAGCTTGAGGAAAATTCTCAGACTATGTTT
CTCTCTCGCAGAAGCAGCGGAGGCAACATGGAAGCCCAAGGGAAGAACTCTAGTGATGAT
AGGGAGGTCAATTTACCTAGTAAAATTCTGAATAGATAG

+ +

fastq文件 ：
详细介绍可以观看：https://www.omicsclass.com/course/28

+
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
@A00808:122:HM2JCDSXX:1:1101:3025:1000 1:N:0:TCGGAAGT+ACAAGGCT
AATTATTCCAAGTGATCATTTAATTTAACAGTACGTTATTACAGTTTTTGACAATACACCAGGAGGGGCAGAAGCAGCACTCCATTTATGCGCCGAATTCTCGTACAGACACACACACACACACAGATTCACACAGTCAATTCAGTCCTT
+
FFFFFFFFFFFF:FFFF:FFFFFFFFFFFFFFFFFFF,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:
@A00808:122:HM2JCDSXX:1:1101:4399:1000 1:N:0:TCGGAAGT+ACAAGGCT
CTTTGCTATAAACTAAGTCACCTTCTACAGCCTGCGAAATGCCATATTTTTCAACTCTGGCACTGGCAGCATGGTTCCAGAGGTAACTTTGGTAACTATGAACGTACATCATTCGTAATGTTCTTGGTATACTCTTTAATGCTTGCAGAT
+
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:F,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
@A00808:122:HM2JCDSXX:1:1101:8522:1000 1:N:0:TCGGAAGT+ACAAGGCA
NACTTTTCAGATTTCAACTTGAGAGATGGACCATCAAGAGCCTTTTTCATGTCACGTTTTTGAGCCATACAATGATACAGACGAAAGAAAACAAGCCAAACAACTCATCCAACCGACCGCGAACAGTAGACACAATTACACAAACACATG
+
#FFF,:FFF:,:FFF:F:FF:FFFFFF:FFF,F:FFF,F,:FF,:FFFF:FFFFF:FF,FF::,,FFFFFFFF:F:FFF,,,FFFFFF,FFF,:,:F::FFFFFFFFFFFFFF,FFFFFF:FFF,,F:,,F:F,:,FFF:,,FF:,FFFF
@A00808:122:HM2JCDSXX:1:1101:13205:1000 1:N:0:TCGGAAGT+ACAAGGCT
NTTCGACGAGGAGGCCGCCTGCGCGCGCGACGCCGCCGGGGAGGCCCTCGCGGCCTTCGAGTCGCTGCTCGCGCGCCTCCCCCCGCCCGACGCCGACTCGCGCCGCCGATCCATGGGGCTCAAGTTGGAGCAGCACAAAGCCGAGCTCAA
+
#FFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFF,F:FFFF,FFFFF,F,FFFFFF:FF:FF:FF:,:,,F,FFFFF,F,:F:FFF:,F,FFFFF,F,:,,,FFF::,:FFFF,FF:,:,:,,FFF,F,FF,,FFFFF,FFFF,FFFF
@A00808:122:HM2JCDSXX:1:1101:3902:1016 1:N:0:TCGGAAGT+ACAAGGCT
GTCGTCGTCACCGAATGTTGTCTTCTTTCCTGCACTAGGTGTACCAGCGCTCTGCTTGAACGGTGTACCCCGTCCACCACGGCCCCTGTCACCCCTACCAAAGCCTCTACCACGTCCACGGTCACCGCGCCCACGGCTACCATCACCACG
+
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFF
@A00808:122:HM2JCDSXX:1:1101:20518:1016 1:N:0:TCGGAAGT+ACAAGGCT
NGCTGGAGAACTAAGTGTCGATCTTCACCTTCACCAACAGATTCATGAACAAACCTAGCAGCGACACAAAAGCAAGACATTAGTAGTTGCAAATATTACTCTATCCAGTTAAGTTAGTATTTGAGAAGAGGGTAGGTGAAGCAGGTCGAA
+
#FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,FFFFFFFF:F,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
@A00808:122:HM2JCDSXX:1:1101:23158:1016 1:N:0:TCGGAAGT+ACAAGGCT
NTCCCTGGACTCTGGGGCACTTTAGGGCTAGGAACACTTGTCAAGCGACTCTGAGGCACAGTATCAGACATGGACTTCGAGAAGGCTTGTGCAAGCTCCAATGCAGATGCTCCTTTCCCAAAACGAGGTGCAACAACCTCAGGCTTTGGT
+
#FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFF
@A00808:122:HM2JCDSXX:1:1101:1597:1031 1:N:0:TCGGAAGT+ACAAGGCT
CGCCGCCGCACTCTGCAACCGCGCCGCGGGGAGGGAGGGAAGGACGAAGGAGGAAGGAGATGGAGCGGGTCGGCGGCGGGGAGAAGCAGCTGGAGGACTGCACCGTGTCCAATGCTCTCGGCACCTGGTTCTTCTCAGTTGCTGGTGCTC
+
F:FFFFFFFFFFFFFFFFFFFFFFFFFF,FF:FFF:FFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,FFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFF
@A00808:122:HM2JCDSXX:1:1101:3351:1031 1:N:0:TCGGAAGT+ACAAGGCT
CCCCCTTGAACTATCCGTAAATACCACCATTCCACCAAACTCCCCTCTGTCTTCTACGACAAATAATCTTTTCAACCCAGTAACTTATAATTAATTACAGAGAGATTAGCAAACATATAATGGTAAGAATCAGTTGTCGTAGGTGCGGCA
+
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFF:FF,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFF
@A00808:122:HM2JCDSXX:1:1101:5466:1031 1:N:0:TCGGAAGT+ACAAGGCT
CTCGCAGTGCTTGGTGTACTTGGCCGGGTCCAGCAGGGCGTCCAGCTCCGACGGGCTGCTCGGCTTCACCTTGATCATCCACCCGTCCTCGTACGGGCTTGAGTTAATCAGGCCGGGTGTCTCAGAGAGCTTGTCGTTAACCTCGACGAC
+
:FF:FF:F,FFFFF,FFFF:::FFF,F::F:F:,F,,,FFF:F::FFFF:FFF:F,:::FF:F,:FFFFFFFFFF,FFFFFFF::FFFF:FFFFFFFF:,FFFFFFFF,F,FF,F,FFF,:F,FFF,FFFF,FFFFF,F:,FFFFFFFFF
@A00808:122:HM2JCDSXX:1:1101:6714:1031 1:N:0:TCGGAAGT+ACAAGGCT
CGACGAGATCGGCCGCTCCGAATCCGATCCGCGCACGTGGTCTCGCCGGCGGGGTCAGGTTGGTTCGCGGGAGCCGCCGCCGCCGCCGACGACGACGACGATGGCCATGGAGACGCCGCCGCCGTTCCAGGAGTCCGCCCACTGCGACGT
+
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

+ +

==任务1 答案：==

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os

os.chdir("D:\\python_script")

idlist={}  #字典用于存储ID列表
f = open("idlist.txt", "r")  #打开ID列表文件
for line in f:
    line=line.strip()
    idlist[line]=1
f.close()

f_out = open("get.fa", "w")
for rec in SeqIO.parse("test.fa", "fasta"):
    if rec.id in idlist:  #判断ID是否存在与ID列表字典中
        SeqIO.write(rec,f_out,"fasta")   #如果存在写出该序列
        
f_out.close()
+

==任务2 答案：==

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os
import re
os.chdir("D:\\python_script")

idlist={}  #字典用于存储ID列表以及位置
f = open("id_pos.txt", "r")  #打开ID列表文件
for line in f:
    line=line.strip()
    tmp=re.split(r"\t",line)
    idlist[tmp[0]]=[int(tmp[1]),int(tmp[2])]
f.close()

f_out = open("get_pos.fa", "w")
for rec in SeqIO.parse("test.fa", "fasta"):
    if rec.id in idlist:  #判断ID是否存在与ID列表字典中
        start=idlist[rec.id][0]  #取得对应ID要截取的起始位置
        end=idlist[rec.id][1]   #取得对应ID要截取的结束位置
        rec_new=SeqRecord(rec.seq[start-1:end],id=rec.id,description=rec.description) #注意生物数据一般是从1作为索引，编程语言一般是从0开始所以要减一
        SeqIO.write(rec_new,f_out,"fasta")   #写出截取好的序列
        
f_out.close()
+ +

==任务3 答案：==

+
1
2
3
4
5
6
7
8
9
10
11
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os

os.chdir("D:\\python_script")
output_handle = open("fq2fa.fa", "w")
for rec in SeqIO.parse("test.fq", "fastq"):
    SeqIO.write(rec, output_handle, "fasta")

output_handle.close()
+ + +

==任务4 答案：==

+
1
2
3
4
5
6
7
8
9
10
11
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os

os.chdir("D:\\python_script")
output_handle = open("trimed.fq", "w")
for rec in SeqIO.parse("test.fq", "fastq"):
    rec_new=rec[5:]
    SeqIO.write(rec_new, output_handle, "fastq")
output_handle.close()
+ +

6 Python 中数据统计分析包numpy 与 pandas

6.1 数据统计分析包介绍

    +

  • NumPy：N维数组矩阵容器； 基础的数学计算模块。

    +
    • +

  • Pandas：表格容器； 提供了一套名为DataFrame的数据结构，适合统计分析表格类数据。

    +
    • +

  • SciPy：科学计算函数库； 基于Numpy，提供方法(函数库)直接计算结果；封装了一些高阶抽象的物理模型。比方说做个傅立叶变换，做个滤波器等等。

    +
    • +
+

==非数学研究，建议直接入手Numpy，pandas。目的，是方便我们处理表格类的生物数据。==

+

6.2 Numpy包学习

Numpy：
用来存储和处理大型矩阵，本身是由C语言开发，和列表（list）的使用很像，但是计算速度要比列表快很多。

+ +

6.2.1 安装

1
2
3
4
5
# 使用 pip
pip install numpy -i  https://pypi.tuna.tsinghua.edu.cn/simple

#导入：
import numpy as np
+ +

6.2.2 矩阵/数组创建函数

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
函数描述
np.array()创建数组
np.zeros()创建数据全为0
np.ones()创建数据全为1
np.empty()创建数据接近0
np.arange()按指定范围创建数据
np.linspace()创建线段
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np #为了方便使用numpy 采用np简写
#列表转化为矩阵
a = np.array([2,23,4])
a = np.array([[11, 12, 13, 14, 15],
              [16, 17, 18, 19, 20],
              [21, 22, 23, 24, 25],
              [26, 27, 28 ,29, 30],
              [31, 32, 33, 34, 35]])
print(a)

#指定数据类型
a = np.array([2,23,4],dtype=np.int)
print(a.dtype)

a = np.arange(10,20,2) # 10-19 的数据，2步长
a = np.linspace(1,10,20)    # 开始端1，结束端10，且分割成20个数据，生成线段

a = np.zeros((3,4)) # 数据全为0，3行4列
a = np.ones((3,4),dtype = np.int)   # 数据为1，3行4列
a = np.empty((3,4)) # 数据为empty，3行4列
+ +
数据类型

NumPy支持的数值类型

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
符号含义
np.boolTrue和Flase
np.int支持int的32或64位
np.int88位的整形(-128~127)
np.int16-32768~32767
np.int32-2 ** 31 ~ 2 ** 31 - 1
np.int64-2 ** 63 ~ 2 ** 63 - 1
np.uint88位的整形(0~255)
np.uint16-32768~32767
np.uint320 ~ 2 ** 32 - 1
np.uint640 ~ 2 ** 64 - 1
np.float161位符号位，5位指数位，10位
np.float321位符号位，8位指数位，23位
np.float64、np.float1位符号位，11位指数位，52位
+

6.2.3 特定分布随机数创建矩阵函数

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
函数说明
np.random.rand(d0,d1,…,dn)根据d0-dn(维度)创建随机数数组，[0,1)，均匀分布
np.random.randn(d0,d1,…,dn)根据d0-dn(维度)创建随机数数组，标准正态分布
np.random.randint(low[,high,shape])根据shape创建随机整数或整数数组，范围是[low,high)
np.random.normal(loc,scale,size)产生具有正态分布的数组，loc为均值，scale标准差，size为形状
np.random.permutation(a)根据数组a的第1轴产生一个新的乱序数组，不改变数组a
np.random.choice(a[,size,replace,p])从一维数组a中以概率p抽取元素，形成size形状新数组replace表示是否可能重用元素，默认为False
np.random.uniform(low,high,size)产生具有均匀分布的数组，low起始值，high结束值，size为形状
np.random.poisson(lam,size)产生具有泊松分布的数组，lam为随机事件发生率，size为形状
+
1
2
3
4
5
6
7
8
import numpy as np #为了方便使用numpy 采用np简写

#产生均匀分布的数据，2x3x4 三维数据
np.random.rand(2,3,4) 

# 产生20个均值为2、标准差为0.1满足正态分布的随机数序列
a = np.random.normal(2, 0.1, 20)

+ + + +

6.2.4 矩阵/数组对象相关方法与属性

reshape() 和resize()方法
    +
  • reshape()方法，在reshape方法里以元组、列表给出变化后的形状数据，并不影响原数组会新生成一个多维数组。
    • +
  • resize() 方法，会修改数组本身的shape属性来改变数组的维度，原数组发生改变。
    • +
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import numpy as np


#reshape方法，注意a被修改了
a = np.arange(12)
print(a)
a.reshape((3, 4))  
print(a)

#resize方法，注意a被修改了
a = np.arange(12)
a.resize([3, 4])
print(a)


#通过属性修改维度，注意a被修改了
a = np.arange(12)
print(a)
a.shape = (2, 6)


+ +
数组的一些属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Array properties
import numpy as np
a = np.array([[11, 12, 13, 14, 15],
              [16, 17, 18, 19, 20],
              [21, 22, 23, 24, 25],
              [26, 27, 28 ,29, 30],
              [31, 32, 33, 34, 35]])

print(type(a)) # >>><class 'numpy.ndarray'>    正如你在上面的代码中看到的，NumPy数组实际上被称为：多维数组，ndarray。
print(a.dtype) # >>>int32    数据类型
print(a.size) # >>>25    数据总个数
print(a.shape) # >>>(5, 5)   数组的形状是它有多少行和列，上面的数组有5行和5列，所以它的形状是(5，5)。
print(a.ndim) # >>>2   数组的维数。

+ + + +
矩阵数据支持索引，切片 类似列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import numpy as np
a = np.arange(24)
print (a[3])

#二维数组索引
#对于2D数组：行的切片，列的切片。
a = np.arange(12)
a = a.reshape((3, 4))
print(a[0, 1:4])
print(a[1:4, 0])
print(a[::2,::2])

#三维数组索引
a = np.arange(24)
b = a.reshape((2, 3, 4))
print (b[1,1:2,1:])

+ +
数组支持布尔筛选
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import numpy as np
a = np.arange(0, 100, 10)
b = a[:5]
c = a[a >= 50]
print(b) 
print(c) 


# Where 函数筛选
a = np.arange(0, 100, 10)
b = np.where(a < 50) 
c = np.where(a >= 50)[0]
print(b) 
print(c)
+ + + +

6.2.5 NumPy的数学统计函数

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
函数说明
np.abs() np.fabs()计算数组各元素的绝对值
np.sqrt()计算数组各元素的平方根
np.square()计算数组各元素的平方
np.log(x),np.log10(x),np.log2(x)计算数组各元素的自然对数、10底对数和2底对数
np.ceil(x),np.floor(x)计算数组各元素的ceiling值或floor值
np.rint(x)计算数组各元素的四舍五入值
np.modf(x)将数据各元素的整数和小数部分以两个独立的数组形式返回
np.cos/cosh/sin/sinh/tan/tanh计算数据各元素的普通型和双典型的三角函数
np.exp(x)计算数组各元素的指数值
np.sum(a,axis=None)根据给定axis计算数组a相关元素之和，axis整数或元组
np.mean(a,axis=None)根据给定axis计算数组a相关元素的期望，axis整数或元组
np.average(a,axis=None,weights=None)根据给定axis计算数组a相关元素的加权平均值
np.std(a,axis=None)根据给定轴axis计算数组a相关元素的标准差
np.var(a,axis = None)根据给定轴axis计算数组a相关元素的方差
np.cov(a,axis = None)计算协方差
np.corrcoef计算相关系数，参阅
np.min(a) max(a)计算数组a中元素的最小值，最大值
np.argmin(a) argmax(a)计算数组a中元素的最小值，最大值的降一维后下标
np.unravel_index(index,shape)根据shape将一维下标index转换成多维下标
np.ptp(a)计算数组a中元素最大值和最小值的差
np.median(a)计算数组a中元素的中位数(中值)
+

iris.data测试数据下载：https://archive.ics.uci.edu/ml/machine-learning-databases/iris/

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import numpy as np
import os
os.chdir("D://python_script//")
a, b = np.loadtxt("iris.data",  delimiter=',', usecols = [0, 1],unpack=True)
print(a)
print(b)

print(np.average(a))
print(np.mean(a))
print(np.max(a))
print(np.argmax(a))
print(np.min(a))
print(np.argmin(a), a[np.argmin(a)])
print(np.ptp(a))
print(np.std(a))
print(np.median(a))
print(np.sqrt(a), np.square(a))
print(np.rint(a))
print(np.ceil(a))


#print(np.column_stack([a, b]))
+

NumPy的算术运算，类似线性代数计算

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import numpy as np
# Basic Operators
a = np.arange(25)
a = a.reshape((5, 5))

b = np.array([10, 62, 1, 14, 2, 56, 79, 2, 1, 45,
              4, 92, 5, 55, 63, 43, 35, 6, 53, 24,
              56, 3, 56, 44, 78])
b = b.reshape((5,5))

print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a ** 2)
print(a < b) 
print(a > b)
+ + +

6.3 Pandas简介

基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。最具有统计意味的工具包，某些方面优于R软件。数据结构有一维的Series，二维的DataFrame，三维的Panel。

+ +

Pandas数据类型

    +
  • Series：一维数组，与Numpy中的一维array类似。二者与Python基本的数据结构List也很相近，其区别是：List中的元素可以是不同的数据类型，而Array和Series中则只允许存储相同的数据类型，这样可以更有效的使用内存，提高运算效率。
    • +
  • DataFrame：二维的表格型数据结构。很多功能与R中的data.frame类似。可以将DataFrame理解为Series的容器。
    • +
  • Time-Series：以时间为索引的Series。
    • +
  • Panel：三维的数组，可以理解为DataFrame的容器。则可以视为excel的多表单sheet。
    • +
+

6.3.1 安装

1
2
3
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple/  pandas

import pandas as pd
+ +

6.3.2 创建Series

Series构造函数的name参数是给这列数据指定字段名。从结果可以看出t有两个名为’a’的label，值分别为2和7。

+
1
2
3
4
5
6
7
8
9
10
11
import pandas as pd
i = ["a", "c", "d", "a"]
v = [2, 4, 5, 7]
t = pd.Series(v, index=i, name = "col_name")
print(t)

#数据的访问，支持索引，切片，name取值
print("t[d]->", t["d"])
print('t[0 : 3]->', t[0 : 3])
print('t["a" : "c"]->', t["c" : "d"])  #注意label唯一才行，不然会报错

+ +

image

+

Series对象的方法与属性

get方法

首先看看get方法，可以返回指定的key所对应的value值

+
1
2
3
4
5
6
7
8
import pandas as pd
idx =  "hello the cruel world".split()
val = [1, 21, 13, 104]
t = pd.Series(val, index = idx)

t.get("the")
t.get("The", "None")  #如果key不存在，返回default的值。

+ +
add、append方法

add和append方法都能改变series，只不过add类似于加法操作，而append则是连接。

+
1
2
3
4
5
6
7
8
9
10
11
12
13
import pandas as pd
idx =  "hello the cruel world".split()
val1 = [1, 21, 13, 104]

t = pd.Series(val1, index = idx)

val2 = [4, 4, 4, 4]
s = pd.Series(val2, index = idx)
t.add(s) 
t + 4

t.append(s)

+ +

6.3.3 DataFrame创建

Pandas的Dataframe是二维的，每一列都是一个Series结构。

+
1
2
3
4
5
6
7
8
9
10
11
12
#手动创建
import pandas as pd
import numpy as np
df1 = pd.DataFrame({'A': 1.,
                    'B': pd.date_range('20130101', periods=4),
                    'C': pd.Series(1, index=list(range(4)), dtype='float32'),
                    'D': np.array([3] * 4, dtype='int32'),
                    'E': ["test", "train", "test", "train"],
                    'F': 'foo'},index=list("abcd"))
#numpy矩阵手动创建
df2 = pd.DataFrame(np.random.randn(10,3), columns = ["ca", "cb", "cc"], index =list("abcdefghij"))

+ + + +

DataFrame对象的属性与方法学习

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
属性描述
columnscolumns属性可以获得dataframe有那些列，即dataframe的index
shapeshape属性是描述dataframe的形状的
sizedataframe的size属性返回的是dataframe的value的个数
values返回当前dataframe的数据和index、columns相对应。
dtypes述当前dataframe的里的每列值的数据类型。
ndim返回数据框维度
Tdataframe的T属性，实际是转置的意思。
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10,3), columns = ["ca", "cb", "cc"], index =list("abcdefghij"))
df.columns
df.index
df.shape
df.size
df.values
df.dtypes
df.ndim
df.T

#方法
df.head()
df.tail(3)
df.to_numpy()
df.describe()  #方法显示数据的快速统计摘要
+ + +

DataFrame数据访问与筛选

需要特别注意的是DataFrame和其他表格数据不一样的是，DataFrame是列访问机制。

+
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
32
33
34
35
import pandas as pd
import numpy as np
val = np.arange(10, 40).reshape(10, 3)
idx = ["ax", "bx", "cx"]
df = pd.DataFrame(val, columns = idx,index=list("abcdefghij"))

#[]号访问列
df["ax"]   #单列索引
df[["ax", "cx"]]  #多列手动选择

#利用列名访问列
df.ax

#DataFrame[start:end]则是通过切片选择的是行。
df["a" : "e"]
df[:3]    #多列切片


###利用方法进行选择

#按位置索引选择：iloc[]行列切片
df.iloc[1] #单独使用选择行
df.iloc[2 : 6, 0 : 2]   #行列选择
df.iloc[[0, 1, 3]]   #不同行选择
df.iloc[[0, 1, 3],[2,1]]   #不同行列选择


#按标签选择  loc[]行列切片， 行列的名字  dataFrame里可以通过loc[]的方式选择label标识的行数据。
df.loc["a"] #单独使用选择行
df.loc[["a","c"]]
df.loc[["a","c"],["ax","cx"]]
df.loc["b" : "e", "bx" : "cx"]
df.loc[: , "bx" : "cx"]


+ +
bool逻辑筛选数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import pandas as pd
import numpy as np
val = np.arange(10, 60).reshape(10, 5)
col = ["ax", "bx", "cx", "dx", "ex"]
idx = list("abcdefghij")
df = pd.DataFrame(val, columns = col, index = idx)

#筛选，bx列大于30的数据
bs = df["bx"] > 30
df[bs]

#组合选择，bx列大于30的数据并且cx列大于40的数据

bs = (df["bx"] > 30) & (df["cx"] > 40)
df[bs]     #选择符合条件的行

#布尔选择的结果还是DataFrame，所以对于结果可以进行切片、label、loc等访问。

+ + +
dataframe数据分类统计（重要）

apply 方法 和 groupby方法对数据进行分类统计

+
1
2
3
4
5
6
7
8
9
10
11
import pandas as pd
import numpy as np
val = np.arange(10, 60).reshape(10, 5)
col = ["ax", "bx", "cx", "dx", "ex"]
idx = list("abcdefghij")
df = pd.DataFrame(val, columns = col, index = idx)

df.apply(lambda col : col.sum(), axis = 0)  #求列的和
df.apply(lambda row : row.sum(), axis = 1)  #求行的和
df["plus"] = df.apply(lambda row : row.ax + row.cx, axis = 1) #两列相加，并增加新列，plus
df
+

groupby 方法，实现分类汇总

+
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
32
import pandas as pd
idx = [101,101,101,102,102,102,103,103,103]
name = ["apple","pearl","orange", "apple","pearl","orange","apple","pearl","orange"]
price = [1.0,2.0,3.0,4.00,5.0,6.0,7.0,8.0,9.0]
df0 = pd.DataFrame({ "fruit": name, "price" : price, "supplier" :idx})

dg =  df0.groupby("fruit")

#批量查看分组结果
for n, g in dg:
    print("group_name:", n, "\n",g,)

#分析结果总结
dg.describe()

#选择需要研究的列,属性或者方法获得统计结果
dg['price'].mean() 
dg['supplier'].value_counts()


#多个分组，大分组之后再分亚组
import pandas as pd
idx = [101,101,101,102,102,102,103,103,103,101,101,101,102,102,102,103,103,103]
name = ["apple","pearl","orange", "apple","pearl","orange","apple","pearl","orange","apple","pearl","orange", "apple","pearl","orange","apple","pearl","orange"]
price = np.arange(18)
df0 = pd.DataFrame({ "fruit": name, "price" : price, "supplier" :idx})

dg2 =  df0.groupby(["fruit", "supplier"])
for n, g in dg2:
    print("multiGroup on:", n, "\n",g)
dg2.describe()

+ +

==groupby方法总结==

+
+

首先通过groupby得到DataFrameGroupBy对象, 然后选择需要研究的列,这样我们就得到了一个SeriesGroupby, 它代表每一个组都有一个Series
对SeriesGroupby进行操作, 比如.mean(), 相当于对每个组的Series求均值

+
+

6.3.4 pandas 应用：读入写出数据处理数据

测试数据：https://archive.ics.uci.edu/ml/machine-learning-databases/iris/

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import os
import pandas as pd
os.chdir("D://python_script//")
fn = "D://python_script//iris.data"
cols_name = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'class']
df = pd.read_csv(fn, names = cols_name)  #更多读取数据：https://pandas.pydata.org/pandas-docs/stable/reference/io.html

data_df=df.iloc[:,0:4]   #筛选一下数据

#利用apply计算：行列的和

data_df.apply(lambda col : col.sum(), axis = 0)
data_df.apply(lambda row : row.sum(), axis = 1)

#自定义计算
data_df["sepal_length x sepal_width"] =data_df.apply(lambda row : row.sepal_width * row.sepal_length, axis = 1)
data_df

data_df.to_csv("out.csv")  #计算结果写出

+ + + + + +
+ + + + +
+
+
+
+ + + + + + + +
+ + + + + +
+

+ + +

+ +
+ + + + + 发表于 + + + + + + + + + 分类于 + + + + + + + +
+
+ + + + +
+ + + + + + + + + + + + + + + +
imageimageimage
问答社区网站（电脑使用）：http://www.omicsclass.com/组学大讲堂问答小程序(手机使用)组学大讲堂公众号
+
+

Python基础语法学习

语法

    +

  • 注释：

    +

    使用 #表示注释行,一般井号在行首，也可以在行的中间，那么#后面的为注释信息

    +

    带有 #号的行python解释器会忽略

    +
    • +

  • 缩进

    +

    使用缩进表示层次关系，或者区分不同的代码块，不像perl语言用{}

    +

    约定使用4个空格缩进

    +
    • +

  • 续行

    +

    在行尾使用 \

    +

    如果使用各种括号，认为括号内是一个整体，括号内部跨行不用 \

    +
    • +
+

Python示例代码：

+
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
32
33
34
35
36
37
38
39
40
41
42
'''
Description: This script is used to onvert U in fasta sequence file to T
Date: 2019
Auther: omicsgene
'''

from Bio.Seq import Seq
from Bio import SeqIO
from Bio.Alphabet import IUPAC
from Bio.SeqRecord import SeqRecord
import sys, os, argparse, os.path,re,math,time
#参数设置
parser = argparse.ArgumentParser(description='This script is \
    used to onvert U in fasta sequence file to T')
parser.add_argument('-f','--fasta',help='Please fasta file',required=True)
parser.add_argument('-o','--out_dir',help='Please input complete out_put directory path',
                    default = os.getcwd(),
                    required=False)

parser.add_argument('-n','--name',default ='demo_seq',required=False,
                    help='Please specify the output, demo_seq')
################################################################################
#读入参数，初始化路径
args = parser.parse_args()
dout=''
if os.path.exists(args.out_dir):
    dout=os.path.abspath(args.out_dir)
else:
    os.mkdir(args.out_dir)
    dout=os.path.abspath(args.out_dir)

output_handle = open(dout+'/'+args.name+'.fa', "w")
#循环处理序列将U转换成T,然后输出
for rec in SeqIO.parse(args.fasta, "fasta"):
    seq=rec.seq
    seq=str(seq.upper())
    seq=seq.replace("U", "T")
    seq_r = SeqRecord(Seq(seq,alphabet = IUPAC.IUPACAmbiguousDNA()), 
                      id=rec.id,
                      description=rec.description)
    SeqIO.write(seq_r, output_handle, "fasta")
output_handle.close()
+ + + + +

Python 标准数据类型和变量

数字：

    +
  • 整数 integer： 11，223，-23
    • +
  • 布尔值 bool ：True False
    • +
  • 浮点数 float： 1.2 、 1.46 、 1.44e10 、 -1.6e-66
    • +
  • 复数： 1+2j
    • +
+

字符串 string：

    +
  • 使用 ‘ “ 单引号或者双引号引用的字符
    • +
  • ‘’’ 和 “”” 可以跨行，可以在其中任意的使用单双引号
    • +
+

空值

1
None
+ + +

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

+

变量：

变量：

+

和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。

+

变量名：

+
    +
  1. 必须是大小写英文字母、数字和 _ 的组合，且不能用数字开头。例如，可将变量命名为message_1，但不能将其命名为1_message。
    2. +
  2. 变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greeting message会引发错误。
    3. +
  3. 不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print。
    4. +
  4. 变量名应既简短又具有描述性，让人一看就知道里面代表的是什么数据。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。
    5. +
  5. 慎用小写字母l和大写字母O，因给他们可能被人错看成数字1和0；
    6. +
+
1
2
3
4
a = 123 # a是整数
print(a)
a = 'ABC' # a变为字符串
print(a)
+ +

变量的理解

1
2
3
4
a = 'abc'
b = a
a = 'xyz'
print(b)
+ +

1： 执行a = ‘abc’，解释器创建了字符串’abc’和变量a，并把a指向’abc’：

+
1
2
graph LR
a-->abc
+

2：执行b = a，解释器创建了变量b，并把b指向a指向的字符串’abc’：

+
1
2
3
graph LR
a-->abc
b-->abc
+ +

3：执行a = ‘xyz’，解释器创建了字符串’xyz’，并把a的指向改为’xyz’，但b并没有更改：

+
1
2
3
graph LR
a-->xyz
b-->abc
+ + +

Python 标准数据的操作

数字操作运算

    +
  • 加减乘除 + - * /
    • +
  • 求余运算 % 求幂运算 **
    • +
  • 自然除/ 结果是浮点数，整除//。注意：在2.x中/和//都是整除。
    • +
+

注意：字符串可以相加和相乘

+

字符串中特殊字符的转义：\

    +
  • 例如要在字符串中输入一个换行符： 
    1
    "hello python\n"
    • +
  • 其他常见特殊意义的转义：
    1
    \\  \t  \r  \n  \'  \"
    • +
  • 字符前缀 r
    • +
+
1
print(r'my name is \n \"lucy\"')
+ + + +

练习：
打印以下变量

+
1
2
3
4
5
6
7
x = 122223
y = 45116e-789
a1 = 'Hello, world'
a2 = 'Hello, \'Lily\''
a3 = r'Hello, "Mike"'
a4 = r'''Hello,
omicsclass!'''
+ +

字符串格式化输出

    +
  • %运算符格式化字符串
    • +
  • %s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。
    • +
+
1
2
3
4
print('Age: %s. Gender: %s' % (25, True))
print('growth rate: %d %%' % 7)
print('%2d-%02d' % (3, 1))
print('%.2f' % 3.1415926)
+ + + +

关于字符串操作的一些方法

==重点掌握：split，strip，join==

+

方法的调用用 . 操作符

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法说明
strip、rstrip、lstrip去除空白符。相当于对各个元素执行x.strip()
split通过指定的分隔符将字符串拆分为一组子串
join将字符串用作连接其他字符串序列的分隔符
count返回子串在字符串中出现次数
endswith、startswith如果字符串以某个后缀结尾（或开头），则返回True
lower、upper分别将字母字符转换为小写或大写
replace用另一个字符串替换指定子串
ljust、rjust用空格(或其他字符)填充字符串的空白侧以返回符合最低宽度的字符串
index如果在字符串中找到子串，则返回子串第一个字符所在的位置。如果没有找到，则引发ValueError
find如果在字符串中找到子串，则返回第一个发现的子串第一个字符所在的位置。如果没有找到，则返回-1
rfind如果在字符串中找到子串，则返回最后一个发现的子串的第一个字符所在的位置。如果没有找到，则返回-1
+

示例代码：

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

s = 'A,T,C,G,A\n'
print(s)
print(s,end="")
print(s.strip())

s = 'A,T,C,G,A'
s.split(',')

"\t".join(["A","T","T"])


s = 'A,T,C,G,A'
s.replace('A','T')
s.count(',')
s.index('c')
s.find('c')
s.endwith("A")
s.lower()

#函数
len(s)


+ +

注意: 调用函数或者方法，一定要跟()

+

==小知识==
Python中函数和方法的区别：

+

在Python中，函数(function) 和方法(method) 是有区别的：

+
    +

  • 所处的位置不同：函数是直接写在文件中而不是class中，方法是只能写在class中。

    +
    • +

  • 调用的方式不同：函数可以直接调用，例如：len() print()等等，方法是在类中，一般用. 来调用，如： 前面学习的：lst.index()

    +
    • +
+

python中的列表list和元组tuple

介绍

list 列表

+
    +
  • list是一种有序的集合，可以随时添加和删除其中的元素。
    • +
  • 元素的类型可以是任意对象(数字，字符串，逻辑值，列表，对象等等)
    • +
  • 使用[]表示列表
    • +
+

tuple 元组

+
    +
  • tuple：另一种有序列表,tuple和list非常类似，但是tuple一旦初始化就不能修改。
    • +
  • 使用()表示元组
    • +
+

list的创建与初始化：

+
1
2
3
mylst=[]
mylst=[1,3,"a","xy",[11,22]]

+ +

tuple的创建：

+
1
2
classmates = ('Michael', 'Bob', 'Tracy')
t = ('a', 'b', ['A', 'B'])
+ + + +

列表list相关的操作&函数&方法

列表的查询：

支持索引用中括号：[]
    +
  • 正索引：从左到右，从0开始
    • +
  • 负索引：从右往左，从-1开始
    • +
+
1
2
3
4
5
6
lst=["A","T","A","a",22,[333,444]]

lst[1]
lst[0]
lst[-1]

+ +
列表切片
1
2
3
4
5
6
7
8
lst=["A","T","A","a",22,[333,444]]
lst[0:3]
#表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
#如果第一个索引是0，还可以省略：
lst[:3]

lst[-2:-1]
lst[-2:]
+
注意多维[][]
1
2
lst=["A","T","A","a",22,[333,444]]
lst[5][0]
+ +

列表元素修改

1
2
3
4
5
lst=["A","T","A","a",22,[333,444]]
lst[5][0]=333

lst[0]="omicsclass"

+ + +

列表相关方法:

重点掌握方法：==append extend sort==

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法功能
list.append(x)在列表末尾添加新的对象
list.sort(key=None, reverse=False)对原列表进行排序
list.extend(iterable)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.count(x)统计某个元素在列表中出现的次数
list.index(x[, start[, end]])从列表中找出某个值第一个匹配项的索引位置
list.insert(i, x)将对象插入列表
list.pop([i])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(x)移除列表中某个值的第一个匹配项
list.reverse()反向列表中元素
+

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
lst=["A","T","A","a",22,[333,444]]
#列表结尾追加元素
lst.append("omicsgene") 

#将可迭代的对象元素追加进来；
lst.extend(["omicsgene","omicsclass"]) 

#在指定的索引处插入元素
lst.insert(1,"omicsclass") 

#从左到右查询第一个匹配的元素删除
lst.remove("A")  

#不指定索引，就从列表结尾删除元素，并返回该元素
#也可以指定索引弹出；
lst.pop()
lst.pop(2)

#反转list，会修改原列表

lst.reverse()
+ +

列表相关的函数

+ + + + + + + + + + + + + + + + + + + + + + +
函数功能
len(list)列表元素个数
list(iterable)将可迭代对象转换为列表
max(list)返回列表元素最大值
min(list)返回列表元素最小值
+
1
2
3
4
5
6
7
8
a=[11,44,5,55,33,31,62,42]
len(a)
max(a)
min(b)

list([11,44,5,55,33,31,62,42])
list(range(10))

+ +

列表的排序

有全局函数sorted，和列表自带方法sort

+

list.sort(key=None, reverse=False)

+
    +
  • key 指定带有一个参数的函数或者方法，用于从每个列表元素中提取比较键(例如key=str.lower)。对应于列表中每一项的键会被计算一次，然后在整个排序过程中使用。默认值None表示直接对列表项排序而不计算一个单独的键值。
    • +
  • reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
    • +
+
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
## 1、最简单的排序
l = [5,2,3,1,4 ]
l.sort()
print(l)   

#反序
l.sort(reverse=True)
print(l)    

##2、字符串排序
StrList = ['Fast', 'Smooth', 'fast', 'isb', 'isa', 'smooth']
#一般字典序排列，但是大写在前，小写在后！！
StrList.sort()
print(StrList) 

##2.2忽略大小写，按abcd顺序
StrList.sort(key=str.lower)
print(StrList) 

##2.3按照字符串长度排序
StrList.sort(key=len)
print(StrList)

#一起使用两个参数
StrList.sort(key=len, reverse=True)
print(StrList)
+ + +

sorted(iterable, key=None, reverse=False)

+
    +
  • iterable – 可迭代对象。 例如：列表 range对象 字符串等
    • +
  • key – 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。
    • +
  • reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
    • +
+
1
2
3
4
5
6
7
8
9
a = [5,7,6,3,4,1,2]
b = sorted(a)       # 保留原列表
print(b)
b = sorted(a,reverse=True)  
print(b)
a = ['Fast', 'Smooth', 'fast', 'isb', 'isa', 'smooth']
b = sorted(a,key=str.lower,reverse=False)  
print(b)

+ +

sort 与 sorted 区别：

+
    +

  • 调用方式不同：
    sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

    +
    • +

  • 返回对象不同：
    list 的 sort 方法是在原来的列表上操作，无返回值（None），而函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

    +
    • +
+

python中的字典dict和集合set

    +
  • dict 字典
    • +
+

dict全称dictionary，使用键-值（key-value）存储，具有极快的查找速度。类似perl里面的hash。

+

字典的创建

字典的每个键值 key=>value对 用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

+
1
dict = {'a': 1, 'b': 2, 'b': '3'}
+

字典的特性：

    +
  1. 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行(列表是可变类型)：
    2. +
  2. 值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的。
    3. +
+
1
2
3
4
d = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'} 

#会报错
d = {['Name']: 'Zara', 'Age': 7}
+ +

修改字典

向字典中 添加新内容的方法是增加新的键/值对，修改或删除已有键/值对:

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
d = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
d['Name']                        #取值
d['Age'] = 18                    # 更新
d['School'] = "omicsclass"       # 添加
 
#取值打印
print( "d['Age']: ", d['Age'])
print("d['School']: ", d['School'])


# 删除字典元素


d = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
del d['Name']  # 删除键是'Name'的条目
d.clear()      # 清空字典所有条目
del d          # 删除字典
 
print("d['Age']: ", d['Age'])
print("d['School']: ", d['School'])
+ +

字典内置方法

+ + + + + + + + + + + + + + + + + + + + + + +
方法描述
dict.keys()以列表返回一个字典所有的键
dict.values()以列表返回字典中的所有值
dict.items()以列表返回可遍历的(键, 值) 元组数组
dict.get(key, default=None)返回指定键的值，如果值不在字典中返回default值
+

判断字典key是否存在

+
1
2
3
4
5
6
7
8
9
10


#使用格式：
#key in dict
#key not in dict

d = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
'Name' in d
'Name' not in d

+ + +

集合

    +
  • set 集合
    • +
+

set 集合是一个无序的不重复元素序列。是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

+
    +
  • 集合创建
    • +
+

可以使用大括号 { } 或者 set() 函数创建集合。

+

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

+

集合的创建与运算

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
genes = {'gene1', 'gene1', 'gene2', 'gene3', 'gene4', 'gene5'}

genes = set(['gene1', 'gene1', 'gene2', 'gene3', 'gene4', 'gene5'])

print(genes)   


#集合运算与判断
'gene1' in genes 

'gene11' in genes

#字符有列表特性，所以可以直接set   
a = set('omicsgene')
b = set('omicsclass')

# 集合a中包含而集合b中不包含的元素
a - b                              
# 集合a或b中包含的所有元素
a | b                              
# 集合a和b中都包含了的元素
a & b                              
# 不同时包含于a和b的元素
a ^ b

+ + +

集合常用操作方法

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
方法描述
set.add(x)参数作为一个元素添加到原set集合
set.update(s)可以添加多个元素，且参数可以是列表，元组，字典等
set.remove(x)依据值删除，不存在会抛出异常KeyError
set.discard(x)依据值删除，不存在不会报错
set.clear()清空原set
+

代码示例：

+
1
2
3
4
5
6
7
8
9
10
11
12
13
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
basket.add(("aa","dd"))
basket.update("dcc")
print(basket)


basket.remove("apple")
basket.remove("apple1")
basket.discard("apple1")

basket.clear()


+ + +

数据类型及类型转换

Python3 支持 的标准数据类型总结

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
类型类名
Number（数字）int、float、bool、complex（复数）
String（字符串）str
List（列表）list
Tuple（元组）tuple
Set（集合）set
Dictionary（字典）dict
+

Python3 的六个标准数据类型中：

+
    +
  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
    • +
  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
    • +
+
1
2
3
4
5
6
7
8
9
10
11
#批量赋值
a, b, c, d ,e= 20, 5.5, "ATGC", True, 4+3j

#获得数据类型
print(type(a), type(b), type(c), type(d), type(e))

#判断数据类型
a=1
isinstance(a, int)


+ + +

类型转换函数：

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
函数描述
int(x [,base])将x转换为一个整数
float(x)将x转换到一个浮点数
str(x)将对象 x 转换为字符串
list(s)将序列 s 转换为一个列表
set(s)转换为可变集合
tuple(s)将序列 s 转换为一个元组
dict(d)创建一个字典。d 必须是一个 (key, value)元组序列。
complex(real [,imag])创建一个复数
repr(x)将对象 x 转换为表达式字符串
eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象
frozenset(s)转换为不可变集合
chr(x)将一个整数转换为一个字符
ord(x)将一个字符转换为它的整数值
hex(x)将一个整数转换为一个十六进制字符串
oct(x)将一个整数转换为一个八进制字符串
+

python中语句(if、for、while)

if 语句 做判断

计算机之所以能做很多自动化的任务，因为它可以自己做条件判断。

+

python中常见比较判断运算符

==、 != 、 < 、> 、 >= 、 <=、in、not in

+

注意：in、not in ： 判断值是否存在列表中或者字典的键中

+
示例代码：
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#简单的判断
age = 20
if age >= 18:
    print('your age is', age)
    print('adult')

l=['Fast', 'Smooth', 'fast', 'isb', 'isa', 'smooth']
s = {'gene1', 'gene1', 'gene2', 'gene3', 'gene4', 'gene5'}
d = {'gene1':122, 'gene2':2212, 'gene3':3121, 'gene4':2323, 'gene5':2543}


if 'Fast' not in l:
    print(True)

#else 语句
    
age = 3
if age >= 18:
    print('your age is', age)
    print('adult')
else:
    print('your age is', age)
    print('teenager')


#elif语句    
age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')


#判断条件依次执行，有一个为真就跳出
age = 66
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
elif age >= 60:
    print('old people')
else:
    print('kid')
+ +

逻辑运算符 增加判断条件

    +
  • 与 、或 、非 ： and 、 or 、 not
    • +
+
    +
  1. and 如果第一个表达式为False，后面没有必要计算
    2. +
  2. or 如果第一个表达式是True，后面就没有必要计算了
    3. +
  3. 条件很多不知道判断优先顺序可以添加小括号
    4. +
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#逻辑运算符
age=11
gender="male"

if age>=18 and age<=60 and gender=="female":
    print("adult woman")

if age<18 or age >60 and gender=="female":
    print("kid or old woman")  
    
if age>=18 and age<=60 and not gender=="female":
    print("adult man")


+ +

特殊数据真值表

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
对象/变量值
“”假
“string”真
0假
() 空元组假
[] 空列表假
{} 空字典假
None假
+

for 循环语句

计算机之所以能批量的执行数据分析，就是因为有循环语句。

+

for…in循环，in 后面跟可迭代对象

+
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#列表遍历
names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)
    
    
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)    


#产生连续的数字函数：range(start, stop[, step])

range(10)
range(2,10)
#也可以转换成list对象
list(range(10))
list(range(1, 11))
list(range(0, 30, 5))
list(range(0, 10, 3))
list(range(0, -10, -1))
list(range(0))
list(range(1, 0))


sum = 0
for x in range(101):
    sum = sum + x
print(sum)


sum = 0
for x in range(3,101):
    sum = sum + x
print(sum)


sum = 0
for x in range(3,101,2):
    sum = sum + x
print(sum)


#enumerate函数  同时获取索引还有值

#用法enumerate(sequence, [start=0])

names = ['Michael', 'Bob', 'Tracy']
for index,value in enumerate(names):
    print(index,value)


#字典遍历
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
for k,v in dict.items():
    print(k,v)

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
for k in dict.keys():
    print(k,dict[k])
+ +

while 循环语句

while循环，只要条件满足，就不断循环，条件不满足时退出循环

+
1
2
3
4
5
6
sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)
+ +

循环控制语句

break 提前退出循环
continue 提前结束本轮循环

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
n = 1
while n <= 100:
    if n > 10: # 当n = 11时，条件满足，执行break语句
        break # break语句会结束当前循环
    print(n)
    n = n + 1
print('END')


n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数，执行continue语句
        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)
+ + +

==练习题==

+
    +
  1. for 循环打印星号金字塔：
    2. +
+
1
2
3
4
5
    *
   ***
  *****
 *******
*********
+ +

答案：

+
1
2
3
4
5
6
7
for i in range(1, 6):
     for j in range(0, 6 - i):
         print (" ",end="")
     
     print( "*"*(i),end="")
     print( "*"*(i-1),end="")       
     print("")
+ +
    +
  1. 利用for循环，打印乘法口诀：
    2. +
+
1
2
3
4
5
6
7
8
9
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81
+ +

答案：

+
1
2
3
4
for m in range(1, 10):
    for n in range(1, m+1):
        print("%d*%d=%d\t"%(n,m,n*m), end="")
    print("")
+ + +

python 读写数据文件

python文件读写分为三步

    +
  1. 打开文件获取文件对象
    2. +
  2. 操作文件
    3. +
  3. 关闭文件
    4. +
+
1
2
3
fr = open("test.txt","r")      #打开文件
ff = fr.read()                 #读取文件所有内容  （不建议使用，如果文件内容巨大，内存会爆）
print(ff)
+ +

文件类型

+ + + + + + + + + + + + + + + + + + +
参数描述
r只读，默认模式 打开数据文件
w只写，不可读，若文件不存在则创建，若存在，则删除内容，写入新内容
a只追加，不可读，若文件不存在则创建，存在则追加新内容
+

文件方法（不常用）

前三个方法：在大文件时慎用，会把内容读到内存中，占用大内存

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法描述
f.write()字符串写入一个打开的文件
f.close()刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
f.read()#读取所有内容
f.readline()#读取一行
f.readlines()#读取所有文件内容，返回一个list
f.seek(0)#当前文件指针位置在0位
f.writelines([“a”,”b”])#把列表写入文件
+

文件的读入与写出（常用方法）：

文件的读入与写出主要用的是for循环：

+
1
2
3
4
5
6
7
fr=open("input.fa","r")   #输入文件，读取数据
fw=open("output.fa","w")   #输出文件，写出结果
for line in fr:              #循环一行一行的读取文件                                 
    new_line = line.replace("A","T")                         
    fw.write(new_line)
fr.close()  #关闭文件
fw.close()  #关闭文件
+ + +

测试文件内容：
input.fa

+
1
2
3
4
5
6
7
8
9
10
11
AGTTAGCGGATAATGGCCATCAAAGCAACGCTTACCAACACTGCACCCCTTGTTTTGGAAATGCAACCAC
AAAAGCATTGGACACTTGCTTACTTCAAATAAAACACATTTAAACAATTAGATGACGTGATGGACCAGAA
TGGCGCATCGGGAAGTCATCCGAACAGGCTATCCCAAGGAAGAGGAGCCCATGCGCGCGAACGTGGCGCC
ACAGTTTCCGCGGCGGCAAATCGGAGTAACATTATCGACGAAATGGCCAAAATATGCGAAGCCGATCGCC
AGACTTTCGCCATCGCTCGACGGACTCGGGGTCACGAGCGGCTTGCGGTGGACAACAGCGACTTCGTCGC
CGTGGAGGATCTTATTTTGTCCTACGCAGAGCCCACGCCCGAGGACCAGGTCGAGATGATCATGAGCGAC
TTTTGCTCGTCTCCAACATACGCAGAGGATGAGGATGAGCCCAGCCATGAGTCGGAGCCGTGGTTTCGAT
TTCGCAACAAAAGGATCAGAACCTACAGCCGGAAGAGGGATCCCAAAAGCCACAAGGCCGTTCAAAACGA
GAAGCGTAGAGGTTCCTCAGGCCTCTCCGTGCAGAGGGATCTCAATACTTCGTTCACATCTATGGCTTGT
GATTTCGATGCTTCATCACAGAAGATACACGAGGTCCTTTTGAACCTCAGTCAATACTTTTCCGCGACCG
CGACAGCTTCCGGTCCGACTCCTGTCCCATCGCAAATAGATCTGCCAACCGAAGCAAGGCAGGATT
+ +
+

==学习任务==

+
    +
  • 编写脚本要求：
    • +
  • 读取gff文件，筛选出文件中1号染色体100000-500000之间的基因
    • +
  • 输出基因的名字，染色体，起始位置，终止位置信息用tab分隔各列
    • +
+

输入文件下载地址：

+

ftp://ftp.ensemblgenomes.org/pub/plants/release-44/gff3/arabidopsis_thaliana/Arabidopsis_thaliana.TAIR10.44.chromosome.1.gff3.gz

+

注意：几乎所有的生物数据文件都是文本文件，都可以用notepad++，editplus等文本编辑器打开，不要被文件后缀名迷惑，我们的编程语言python绝大多数情况下打开处理的也都是文本文件。

+
+

答案：

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
fr=open("D:\python_script\Arabidopsis_thaliana.TAIR10.44.chromosome.1.gff3\Arabidopsis_thaliana.TAIR10.44.chromosome.1.gff3","r")
fw=open("D:\python_script\Arabidopsis_thaliana.TAIR10.44.chromosome.1.gff3\out.txt","w")

for line in fr:
    line=line.strip()
    if not line[0]=="#":
        tmp=line.split("\t")
        if tmp[0]=="1" and tmp[2]=="gene" and int(tmp[3])>100000 and int(tmp[3])<500000:
            geneID=tmp[8].split(";")[0].split("=")[1]
            #mystr=tmp[0]+"\t"+tmp[3]+"\t"+tmp[4]+"\t"+geneID+"\n"
            mystr="\t".join([tmp[0],tmp[3],tmp[4],geneID])+"\n"
            fw.write(mystr)
            #fw.write(line+"\n")
    
fr.close()
fw.close()
+ +
+ + + + +
+
+
+
+ + + + + + + +
+ + + + + +
+

+ + +

+ +
+ + + + + 发表于 + + + + + + + + + 分类于 + + + + + + + +
+
+ + + + +
+ + +

Python 绘图matplotlib包科学绘图

Matplotlib:

+

Python中最著名的绘图系统，pandas绘图也是由其封装而成。

+

官方网站：https://matplotlib.org/

+

1 认识matplotlib绘图包绘图要素以及对应的类（对象）

    +
  • Figure
    • +
+

The whole figure. The figure keeps track of all the child Axes, a smattering of ‘special’ artists (titles, figure legends, etc), and the canvas。

+

The top level container Artist is the matplotlib.figure.Figure

+
    +
  • Axes
    • +
+

This is what you think of as ‘a plot’, it is the region of the image with the data space. A given figure can contain many Axes, but a given Axes object can only be in one Figure.

+
    +
  • Axis
    • +
+

These are the number-line-like objects. They take care of setting the graph limits and generating the ticks (the marks on the axis) and ticklabels (strings labeling the ticks).

+
    +
  • Artist
    • +
+

Basically everything you can see on the figure is an artist (even the Figure, Axes, and Axis objects). This includes Text objects, Line2D objects, collection objects, Patch objects … (you get the idea).

+

要素之间的关系：

image

+

多张图，要素之间的关系：

image

+

Figure中更详细对象总结

image

+

2 matplotlib包安装

安装说明：
https://matplotlib.org/users/installing.html#installing-an-official-release

+
1
2
3
4
5
6
pip install matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple

#jupyter 支持绘图显示，命令行需要安装运行以下代码：

pip install ipympl  -i https://pypi.tuna.tsinghua.edu.cn/simple
jupyter nbextension enable --py --sys-prefix ipympl
+ + + +

3 matplotlib绘图基础

matplotlib.pyplot 绘图入口模块

==matplotlib.pyplot 模块中有很多函数，我们直接调用就可以绘图：==

+

Everything in matplotlib is organized in a hierarchy. At the top of the hierarchy is the matplotlib “state-machine environment” which is provided by the matplotlib.pyplot module.

+

我们使用matplotlib.pyplot 里面的函数来创建绘图，绘图主要有以下三步：

+
    +
  • 第一步：创建Figure对象，相当于画布
    • +
  • 第二步：画布中添加Axes对象，画布中可以有很多图（Axes）
    • +
  • 第三步：利用Axes对象的方法绘图（plot，bar，pie等等）
    • +
+

示例代码：

+
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#########################################
#载入包，模块等等
#########################################
import matplotlib.pyplot as plt
import numpy as np

###########################
##第一步和第二步：  获得，Figure对象和Axes对象
###########################

#方法1：
fig = plt.figure(figsize=(8, 6))
ax1 = fig.add_axes([0.1, 0.1, 0.35, 0.8])
ax2 = fig.add_axes([0.55, 0.1, 0.35, 0.8])

#或者
ax1 = fig.add_subplot(211)
ax2 = fig.add_subplot(212)


#方法2：
fig, ax = plt.subplots(figsize=(8, 6))
#或者 
fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2,figsize=(8, 6))

##########################
##第三步： 绘图
#############################

x = np.linspace(0, 2, 100)   
fig, ax = plt.subplots(figsize=(8, 6))



ax.plot(x, x, label='linear')
ax.plot(x, x**2, label='quadratic')
ax.plot(x, x**3, label='cubic')
ax.set_xlabel('x label')
ax.set_ylabel('y label')
ax.set_title("Simple Plot")
ax.legend()

plt.show()

#保存图片
#plt.savefig("D:\\python_script\\test.pdf")
#plt.savefig("D:\\python_script\\test.png",dpi=300)
+ + +

面向对象绘图和面向过程的绘图

推荐面向对象的绘图，思路会更加清晰。

+
1
2
3
4
5
6
7
8
9
10
11
12
13
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2, 100)
plt.plot(x, x, label='linear')
plt.plot(x, x**2, label='quadratic')
plt.plot(x, x**3, label='cubic')
plt.xlabel('x label')
plt.ylabel('y label')
plt.title("Simple Plot")
plt.legend()
plt.show()

+

3 学会自学绘图

方法模板的API：每个类、方法、函数，参数的详细说明

https://matplotlib.org/api/index.html#modules

+

使用说明

https://matplotlib.org/users/index.html

+

利用例子学习绘图

https://matplotlib.org/gallery/index.html

+ + +
+ + + + +
+
+
+
+ + + + + + +
-
+
1 + 分类 +
+
+ 2 标签
diff --git a/search.xml b/search.xml index 69a395c..05aacb4 100644 --- a/search.xml +++ b/search.xml @@ -40,4 +40,2041 @@ 软件 + + Python入门基础课 + /2024/07/02/Python%E5%85%A5%E9%97%A8%E5%9F%BA%E7%A1%80%E8%AF%BE/ + + + +image +image +image + + + +问答社区网站（电脑使用）：http://www.omicsclass.com/ +组学大讲堂问答小程序(手机使用) +组学大讲堂公众号 + + +
+

Python基础语法学习

语法

    +

  • 注释：

    +

    使用 #表示注释行,一般井号在行首，也可以在行的中间，那么#后面的为注释信息

    +

    带有 #号的行python解释器会忽略

    +
    • +

  • 缩进

    +

    使用缩进表示层次关系，或者区分不同的代码块，不像perl语言用{}

    +

    约定使用4个空格缩进

    +
    • +

  • 续行

    +

    在行尾使用 \

    +

    如果使用各种括号，认为括号内是一个整体，括号内部跨行不用 \

    +
    • +
+

Python示例代码：

+
'''
Description: This script is used to onvert U in fasta sequence file to T
Date: 2019
Auther: omicsgene
'''

from Bio.Seq import Seq
from Bio import SeqIO
from Bio.Alphabet import IUPAC
from Bio.SeqRecord import SeqRecord
import sys, os, argparse, os.path,re,math,time
#参数设置
parser = argparse.ArgumentParser(description='This script is \
    used to onvert U in fasta sequence file to T')
parser.add_argument('-f','--fasta',help='Please fasta file',required=True)
parser.add_argument('-o','--out_dir',help='Please input complete out_put directory path',
                    default = os.getcwd(),
                    required=False)

parser.add_argument('-n','--name',default ='demo_seq',required=False,
                    help='Please specify the output, demo_seq')
################################################################################
#读入参数，初始化路径
args = parser.parse_args()
dout=''
if os.path.exists(args.out_dir):
    dout=os.path.abspath(args.out_dir)
else:
    os.mkdir(args.out_dir)
    dout=os.path.abspath(args.out_dir)

output_handle = open(dout+'/'+args.name+'.fa', "w")
#循环处理序列将U转换成T,然后输出
for rec in SeqIO.parse(args.fasta, "fasta"):
    seq=rec.seq
    seq=str(seq.upper())
    seq=seq.replace("U", "T")
    seq_r = SeqRecord(Seq(seq,alphabet = IUPAC.IUPACAmbiguousDNA()), 
                      id=rec.id,
                      description=rec.description)
    SeqIO.write(seq_r, output_handle, "fasta")
output_handle.close()
+ + + + +

Python 标准数据类型和变量

数字：

    +
  • 整数 integer： 11，223，-23
    • +
  • 布尔值 bool ：True False
    • +
  • 浮点数 float： 1.2 、 1.46 、 1.44e10 、 -1.6e-66
    • +
  • 复数： 1+2j
    • +
+

字符串 string：

    +
  • 使用 ‘ “ 单引号或者双引号引用的字符
    • +
  • ‘’’ 和 “”” 可以跨行，可以在其中任意的使用单双引号
    • +
+

空值

None
+ + +

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

+

变量：

变量：

+

和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。

+

变量名：

+
    +
  1. 必须是大小写英文字母、数字和 _ 的组合，且不能用数字开头。例如，可将变量命名为message_1，但不能将其命名为1_message。
    2. +
  2. 变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greeting message会引发错误。
    3. +
  3. 不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print。
    4. +
  4. 变量名应既简短又具有描述性，让人一看就知道里面代表的是什么数据。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。
    5. +
  5. 慎用小写字母l和大写字母O，因给他们可能被人错看成数字1和0；
    6. +
+
a = 123 # a是整数
print(a)
a = 'ABC' # a变为字符串
print(a)
+ +

变量的理解

a = 'abc'
b = a
a = 'xyz'
print(b)
+ +

1： 执行a = ‘abc’，解释器创建了字符串’abc’和变量a，并把a指向’abc’：

+
graph LR
a-->abc
+

2：执行b = a，解释器创建了变量b，并把b指向a指向的字符串’abc’：

+
graph LR
a-->abc
b-->abc
+ +

3：执行a = ‘xyz’，解释器创建了字符串’xyz’，并把a的指向改为’xyz’，但b并没有更改：

+
graph LR
a-->xyz
b-->abc
+ + +

Python 标准数据的操作

数字操作运算

    +
  • 加减乘除 + - * /
    • +
  • 求余运算 % 求幂运算 **
    • +
  • 自然除/ 结果是浮点数，整除//。注意：在2.x中/和//都是整除。
    • +
+

注意：字符串可以相加和相乘

+

字符串中特殊字符的转义：\

    +
  • 例如要在字符串中输入一个换行符： 
    "hello python\n"
    • +
  • 其他常见特殊意义的转义：
    \\  \t  \r  \n  \'  \"
    • +
  • 字符前缀 r
    • +
+
print(r'my name is \n \"lucy\"')
+ + + +

练习：
打印以下变量

+
x = 122223
y = 45116e-789
a1 = 'Hello, world'
a2 = 'Hello, \'Lily\''
a3 = r'Hello, "Mike"'
a4 = r'''Hello,
omicsclass!'''
+ +

字符串格式化输出

    +
  • %运算符格式化字符串
    • +
  • %s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。
    • +
+
print('Age: %s. Gender: %s' % (25, True))
print('growth rate: %d %%' % 7)
print('%2d-%02d' % (3, 1))
print('%.2f' % 3.1415926)
+ + + +

关于字符串操作的一些方法

==重点掌握：split，strip，join==

+

方法的调用用 . 操作符

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法说明
strip、rstrip、lstrip去除空白符。相当于对各个元素执行x.strip()
split通过指定的分隔符将字符串拆分为一组子串
join将字符串用作连接其他字符串序列的分隔符
count返回子串在字符串中出现次数
endswith、startswith如果字符串以某个后缀结尾（或开头），则返回True
lower、upper分别将字母字符转换为小写或大写
replace用另一个字符串替换指定子串
ljust、rjust用空格(或其他字符)填充字符串的空白侧以返回符合最低宽度的字符串
index如果在字符串中找到子串，则返回子串第一个字符所在的位置。如果没有找到，则引发ValueError
find如果在字符串中找到子串，则返回第一个发现的子串第一个字符所在的位置。如果没有找到，则返回-1
rfind如果在字符串中找到子串，则返回最后一个发现的子串的第一个字符所在的位置。如果没有找到，则返回-1
+

示例代码：

+

s = 'A,T,C,G,A\n'
print(s)
print(s,end="")
print(s.strip())

s = 'A,T,C,G,A'
s.split(',')

"\t".join(["A","T","T"])


s = 'A,T,C,G,A'
s.replace('A','T')
s.count(',')
s.index('c')
s.find('c')
s.endwith("A")
s.lower()

#函数
len(s)


+ +

注意: 调用函数或者方法，一定要跟()

+

==小知识==
Python中函数和方法的区别：

+

在Python中，函数(function) 和方法(method) 是有区别的：

+
    +

  • 所处的位置不同：函数是直接写在文件中而不是class中，方法是只能写在class中。

    +
    • +

  • 调用的方式不同：函数可以直接调用，例如：len() print()等等，方法是在类中，一般用. 来调用，如： 前面学习的：lst.index()

    +
    • +
+

python中的列表list和元组tuple

介绍

list 列表

+
    +
  • list是一种有序的集合，可以随时添加和删除其中的元素。
    • +
  • 元素的类型可以是任意对象(数字，字符串，逻辑值，列表，对象等等)
    • +
  • 使用[]表示列表
    • +
+

tuple 元组

+
    +
  • tuple：另一种有序列表,tuple和list非常类似，但是tuple一旦初始化就不能修改。
    • +
  • 使用()表示元组
    • +
+

list的创建与初始化：

+
mylst=[]
mylst=[1,3,"a","xy",[11,22]]

+ +

tuple的创建：

+
classmates = ('Michael', 'Bob', 'Tracy')
t = ('a', 'b', ['A', 'B'])
+ + + +

列表list相关的操作&函数&方法

列表的查询：

支持索引用中括号：[]
    +
  • 正索引：从左到右，从0开始
    • +
  • 负索引：从右往左，从-1开始
    • +
+
lst=["A","T","A","a",22,[333,444]]

lst[1]
lst[0]
lst[-1]

+ +
列表切片
lst=["A","T","A","a",22,[333,444]]
lst[0:3]
#表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
#如果第一个索引是0，还可以省略：
lst[:3]

lst[-2:-1]
lst[-2:]
+
注意多维[][]
lst=["A","T","A","a",22,[333,444]]
lst[5][0]
+ +

列表元素修改

lst=["A","T","A","a",22,[333,444]]
lst[5][0]=333

lst[0]="omicsclass"

+ + +

列表相关方法:

重点掌握方法：==append extend sort==

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法功能
list.append(x)在列表末尾添加新的对象
list.sort(key=None, reverse=False)对原列表进行排序
list.extend(iterable)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.count(x)统计某个元素在列表中出现的次数
list.index(x[, start[, end]])从列表中找出某个值第一个匹配项的索引位置
list.insert(i, x)将对象插入列表
list.pop([i])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(x)移除列表中某个值的第一个匹配项
list.reverse()反向列表中元素
+

示例代码

lst=["A","T","A","a",22,[333,444]]
#列表结尾追加元素
lst.append("omicsgene") 

#将可迭代的对象元素追加进来；
lst.extend(["omicsgene","omicsclass"]) 

#在指定的索引处插入元素
lst.insert(1,"omicsclass") 

#从左到右查询第一个匹配的元素删除
lst.remove("A")  

#不指定索引，就从列表结尾删除元素，并返回该元素
#也可以指定索引弹出；
lst.pop()
lst.pop(2)

#反转list，会修改原列表

lst.reverse()
+ +

列表相关的函数

+ + + + + + + + + + + + + + + + + + + + + + +
函数功能
len(list)列表元素个数
list(iterable)将可迭代对象转换为列表
max(list)返回列表元素最大值
min(list)返回列表元素最小值
+
a=[11,44,5,55,33,31,62,42]
len(a)
max(a)
min(b)

list([11,44,5,55,33,31,62,42])
list(range(10))

+ +

列表的排序

有全局函数sorted，和列表自带方法sort

+

list.sort(key=None, reverse=False)

+
    +
  • key 指定带有一个参数的函数或者方法，用于从每个列表元素中提取比较键(例如key=str.lower)。对应于列表中每一项的键会被计算一次，然后在整个排序过程中使用。默认值None表示直接对列表项排序而不计算一个单独的键值。
    • +
  • reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
    • +
+
## 1、最简单的排序
l = [5,2,3,1,4 ]
l.sort()
print(l)   

#反序
l.sort(reverse=True)
print(l)    

##2、字符串排序
StrList = ['Fast', 'Smooth', 'fast', 'isb', 'isa', 'smooth']
#一般字典序排列，但是大写在前，小写在后！！
StrList.sort()
print(StrList) 

##2.2忽略大小写，按abcd顺序
StrList.sort(key=str.lower)
print(StrList) 

##2.3按照字符串长度排序
StrList.sort(key=len)
print(StrList)

#一起使用两个参数
StrList.sort(key=len, reverse=True)
print(StrList)
+ + +

sorted(iterable, key=None, reverse=False)

+
    +
  • iterable – 可迭代对象。 例如：列表 range对象 字符串等
    • +
  • key – 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。
    • +
  • reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
    • +
+
a = [5,7,6,3,4,1,2]
b = sorted(a)       # 保留原列表
print(b)
b = sorted(a,reverse=True)  
print(b)
a = ['Fast', 'Smooth', 'fast', 'isb', 'isa', 'smooth']
b = sorted(a,key=str.lower,reverse=False)  
print(b)

+ +

sort 与 sorted 区别：

+
    +

  • 调用方式不同：
    sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

    +
    • +

  • 返回对象不同：
    list 的 sort 方法是在原来的列表上操作，无返回值（None），而函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

    +
    • +
+

python中的字典dict和集合set

    +
  • dict 字典
    • +
+

dict全称dictionary，使用键-值（key-value）存储，具有极快的查找速度。类似perl里面的hash。

+

字典的创建

字典的每个键值 key=>value对 用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

+
dict = {'a': 1, 'b': 2, 'b': '3'}
+

字典的特性：

    +
  1. 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行(列表是可变类型)：
    2. +
  2. 值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的。
    3. +
+
d = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'} 

#会报错
d = {['Name']: 'Zara', 'Age': 7}
+ +

修改字典

向字典中 添加新内容的方法是增加新的键/值对，修改或删除已有键/值对:

+
d = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
d['Name']                        #取值
d['Age'] = 18                    # 更新
d['School'] = "omicsclass"       # 添加
 
#取值打印
print( "d['Age']: ", d['Age'])
print("d['School']: ", d['School'])


# 删除字典元素


d = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
del d['Name']  # 删除键是'Name'的条目
d.clear()      # 清空字典所有条目
del d          # 删除字典
 
print("d['Age']: ", d['Age'])
print("d['School']: ", d['School'])
+ +

字典内置方法

+ + + + + + + + + + + + + + + + + + + + + + +
方法描述
dict.keys()以列表返回一个字典所有的键
dict.values()以列表返回字典中的所有值
dict.items()以列表返回可遍历的(键, 值) 元组数组
dict.get(key, default=None)返回指定键的值，如果值不在字典中返回default值
+

判断字典key是否存在

+


#使用格式：
#key in dict
#key not in dict

d = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
'Name' in d
'Name' not in d

+ + +

集合

    +
  • set 集合
    • +
+

set 集合是一个无序的不重复元素序列。是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

+
    +
  • 集合创建
    • +
+

可以使用大括号 { } 或者 set() 函数创建集合。

+

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

+

集合的创建与运算

genes = {'gene1', 'gene1', 'gene2', 'gene3', 'gene4', 'gene5'}

genes = set(['gene1', 'gene1', 'gene2', 'gene3', 'gene4', 'gene5'])

print(genes)   


#集合运算与判断
'gene1' in genes 

'gene11' in genes

#字符有列表特性，所以可以直接set   
a = set('omicsgene')
b = set('omicsclass')

# 集合a中包含而集合b中不包含的元素
a - b                              
# 集合a或b中包含的所有元素
a | b                              
# 集合a和b中都包含了的元素
a & b                              
# 不同时包含于a和b的元素
a ^ b

+ + +

集合常用操作方法

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
方法描述
set.add(x)参数作为一个元素添加到原set集合
set.update(s)可以添加多个元素，且参数可以是列表，元组，字典等
set.remove(x)依据值删除，不存在会抛出异常KeyError
set.discard(x)依据值删除，不存在不会报错
set.clear()清空原set
+

代码示例：

+
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
basket.add(("aa","dd"))
basket.update("dcc")
print(basket)


basket.remove("apple")
basket.remove("apple1")
basket.discard("apple1")

basket.clear()


+ + +

数据类型及类型转换

Python3 支持 的标准数据类型总结

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
类型类名
Number（数字）int、float、bool、complex（复数）
String（字符串）str
List（列表）list
Tuple（元组）tuple
Set（集合）set
Dictionary（字典）dict
+

Python3 的六个标准数据类型中：

+
    +
  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
    • +
  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
    • +
+
#批量赋值
a, b, c, d ,e= 20, 5.5, "ATGC", True, 4+3j

#获得数据类型
print(type(a), type(b), type(c), type(d), type(e))

#判断数据类型
a=1
isinstance(a, int)


+ + +

类型转换函数：

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
函数描述
int(x [,base])将x转换为一个整数
float(x)将x转换到一个浮点数
str(x)将对象 x 转换为字符串
list(s)将序列 s 转换为一个列表
set(s)转换为可变集合
tuple(s)将序列 s 转换为一个元组
dict(d)创建一个字典。d 必须是一个 (key, value)元组序列。
complex(real [,imag])创建一个复数
repr(x)将对象 x 转换为表达式字符串
eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象
frozenset(s)转换为不可变集合
chr(x)将一个整数转换为一个字符
ord(x)将一个字符转换为它的整数值
hex(x)将一个整数转换为一个十六进制字符串
oct(x)将一个整数转换为一个八进制字符串
+

python中语句(if、for、while)

if 语句 做判断

计算机之所以能做很多自动化的任务，因为它可以自己做条件判断。

+

python中常见比较判断运算符

==、 != 、 < 、> 、 >= 、 <=、in、not in

+

注意：in、not in ： 判断值是否存在列表中或者字典的键中

+
示例代码：
#简单的判断
age = 20
if age >= 18:
    print('your age is', age)
    print('adult')

l=['Fast', 'Smooth', 'fast', 'isb', 'isa', 'smooth']
s = {'gene1', 'gene1', 'gene2', 'gene3', 'gene4', 'gene5'}
d = {'gene1':122, 'gene2':2212, 'gene3':3121, 'gene4':2323, 'gene5':2543}


if 'Fast' not in l:
    print(True)

#else 语句
    
age = 3
if age >= 18:
    print('your age is', age)
    print('adult')
else:
    print('your age is', age)
    print('teenager')


#elif语句    
age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')


#判断条件依次执行，有一个为真就跳出
age = 66
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
elif age >= 60:
    print('old people')
else:
    print('kid')
+ +

逻辑运算符 增加判断条件

    +
  • 与 、或 、非 ： and 、 or 、 not
    • +
+
    +
  1. and 如果第一个表达式为False，后面没有必要计算
    2. +
  2. or 如果第一个表达式是True，后面就没有必要计算了
    3. +
  3. 条件很多不知道判断优先顺序可以添加小括号
    4. +
+
#逻辑运算符
age=11
gender="male"

if age>=18 and age<=60 and gender=="female":
    print("adult woman")

if age<18 or age >60 and gender=="female":
    print("kid or old woman")  
    
if age>=18 and age<=60 and not gender=="female":
    print("adult man")


+ +

特殊数据真值表

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
对象/变量值
“”假
“string”真
0假
() 空元组假
[] 空列表假
{} 空字典假
None假
+

for 循环语句

计算机之所以能批量的执行数据分析，就是因为有循环语句。

+

for…in循环，in 后面跟可迭代对象

+
#列表遍历
names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)
    
    
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)    


#产生连续的数字函数：range(start, stop[, step])

range(10)
range(2,10)
#也可以转换成list对象
list(range(10))
list(range(1, 11))
list(range(0, 30, 5))
list(range(0, 10, 3))
list(range(0, -10, -1))
list(range(0))
list(range(1, 0))


sum = 0
for x in range(101):
    sum = sum + x
print(sum)


sum = 0
for x in range(3,101):
    sum = sum + x
print(sum)


sum = 0
for x in range(3,101,2):
    sum = sum + x
print(sum)


#enumerate函数  同时获取索引还有值

#用法enumerate(sequence, [start=0])

names = ['Michael', 'Bob', 'Tracy']
for index,value in enumerate(names):
    print(index,value)


#字典遍历
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
for k,v in dict.items():
    print(k,v)

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
for k in dict.keys():
    print(k,dict[k])
+ +

while 循环语句

while循环，只要条件满足，就不断循环，条件不满足时退出循环

+
sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)
+ +

循环控制语句

break 提前退出循环
continue 提前结束本轮循环

+
n = 1
while n <= 100:
    if n > 10: # 当n = 11时，条件满足，执行break语句
        break # break语句会结束当前循环
    print(n)
    n = n + 1
print('END')


n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数，执行continue语句
        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)
+ + +

==练习题==

+
    +
  1. for 循环打印星号金字塔：
    2. +
+
    *
   ***
  *****
 *******
*********
+ +

答案：

+
for i in range(1, 6):
     for j in range(0, 6 - i):
         print (" ",end="")
     
     print( "*"*(i),end="")
     print( "*"*(i-1),end="")       
     print("")
+ +
    +
  1. 利用for循环，打印乘法口诀：
    2. +
+
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81
+ +

答案：

+
for m in range(1, 10):
    for n in range(1, m+1):
        print("%d*%d=%d\t"%(n,m,n*m), end="")
    print("")
+ + +

python 读写数据文件

python文件读写分为三步

    +
  1. 打开文件获取文件对象
    2. +
  2. 操作文件
    3. +
  3. 关闭文件
    4. +
+
fr = open("test.txt","r")      #打开文件
ff = fr.read()                 #读取文件所有内容  （不建议使用，如果文件内容巨大，内存会爆）
print(ff)
+ +

文件类型

+ + + + + + + + + + + + + + + + + + +
参数描述
r只读，默认模式 打开数据文件
w只写，不可读，若文件不存在则创建，若存在，则删除内容，写入新内容
a只追加，不可读，若文件不存在则创建，存在则追加新内容
+

文件方法（不常用）

前三个方法：在大文件时慎用，会把内容读到内存中，占用大内存

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法描述
f.write()字符串写入一个打开的文件
f.close()刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
f.read()#读取所有内容
f.readline()#读取一行
f.readlines()#读取所有文件内容，返回一个list
f.seek(0)#当前文件指针位置在0位
f.writelines([“a”,”b”])#把列表写入文件
+

文件的读入与写出（常用方法）：

文件的读入与写出主要用的是for循环：

+
fr=open("input.fa","r")   #输入文件，读取数据
fw=open("output.fa","w")   #输出文件，写出结果
for line in fr:              #循环一行一行的读取文件                                 
    new_line = line.replace("A","T")                         
    fw.write(new_line)
fr.close()  #关闭文件
fw.close()  #关闭文件
+ + +

测试文件内容：
input.fa

+
AGTTAGCGGATAATGGCCATCAAAGCAACGCTTACCAACACTGCACCCCTTGTTTTGGAAATGCAACCAC
AAAAGCATTGGACACTTGCTTACTTCAAATAAAACACATTTAAACAATTAGATGACGTGATGGACCAGAA
TGGCGCATCGGGAAGTCATCCGAACAGGCTATCCCAAGGAAGAGGAGCCCATGCGCGCGAACGTGGCGCC
ACAGTTTCCGCGGCGGCAAATCGGAGTAACATTATCGACGAAATGGCCAAAATATGCGAAGCCGATCGCC
AGACTTTCGCCATCGCTCGACGGACTCGGGGTCACGAGCGGCTTGCGGTGGACAACAGCGACTTCGTCGC
CGTGGAGGATCTTATTTTGTCCTACGCAGAGCCCACGCCCGAGGACCAGGTCGAGATGATCATGAGCGAC
TTTTGCTCGTCTCCAACATACGCAGAGGATGAGGATGAGCCCAGCCATGAGTCGGAGCCGTGGTTTCGAT
TTCGCAACAAAAGGATCAGAACCTACAGCCGGAAGAGGGATCCCAAAAGCCACAAGGCCGTTCAAAACGA
GAAGCGTAGAGGTTCCTCAGGCCTCTCCGTGCAGAGGGATCTCAATACTTCGTTCACATCTATGGCTTGT
GATTTCGATGCTTCATCACAGAAGATACACGAGGTCCTTTTGAACCTCAGTCAATACTTTTCCGCGACCG
CGACAGCTTCCGGTCCGACTCCTGTCCCATCGCAAATAGATCTGCCAACCGAAGCAAGGCAGGATT
+ +
+

==学习任务==

+
    +
  • 编写脚本要求：
    • +
  • 读取gff文件，筛选出文件中1号染色体100000-500000之间的基因
    • +
  • 输出基因的名字，染色体，起始位置，终止位置信息用tab分隔各列
    • +
+

输入文件下载地址：

+

ftp://ftp.ensemblgenomes.org/pub/plants/release-44/gff3/arabidopsis_thaliana/Arabidopsis_thaliana.TAIR10.44.chromosome.1.gff3.gz

+

注意：几乎所有的生物数据文件都是文本文件，都可以用notepad++，editplus等文本编辑器打开，不要被文件后缀名迷惑，我们的编程语言python绝大多数情况下打开处理的也都是文本文件。

+
+

答案：

+
fr=open("D:\python_script\Arabidopsis_thaliana.TAIR10.44.chromosome.1.gff3\Arabidopsis_thaliana.TAIR10.44.chromosome.1.gff3","r")
fw=open("D:\python_script\Arabidopsis_thaliana.TAIR10.44.chromosome.1.gff3\out.txt","w")

for line in fr:
    line=line.strip()
    if not line[0]=="#":
        tmp=line.split("\t")
        if tmp[0]=="1" and tmp[2]=="gene" and int(tmp[3])>100000 and int(tmp[3])<500000:
            geneID=tmp[8].split(";")[0].split("=")[1]
            #mystr=tmp[0]+"\t"+tmp[3]+"\t"+tmp[4]+"\t"+geneID+"\n"
            mystr="\t".join([tmp[0],tmp[3],tmp[4],geneID])+"\n"
            fw.write(mystr)
            #fw.write(line+"\n")
    
fr.close()
fw.close()
]]> + + Learn_Python + + + Python + + + + Python 高级编程 + /2024/07/02/Python%E9%AB%98%E7%BA%A7%E7%BC%96%E7%A8%8B/ + + + +image +image +image + + + +问答社区网站（电脑使用）：http://www.omicsclass.com/ +组学大讲堂问答小程序(手机使用) +组学大讲堂公众号 + + +
+

Python高级编程

1 函数

1.1 Python内置函数：

Python内置了很多有用的函数，我们可以直接调用。

+

内置函数总结：https://docs.Python.org/zh-cn/3.7/library/functions.html

+
abs(-100)
max(1, 2)
int('123')
float('12.34')
sum([2,323,23])
+ +

1.2 Python 用户自定义函数

自定义函数：把具有独立功能的代码块组织成为一个小模块。

+

好处：

+
    +
  1. 代码复用，提高编程效率，使程序易于理解。
    2. +
  2. 自己学会定义函数，有助于理解看懂别人函数的帮助
    3. +
+

定义一个函数

你可以定义一个自定义功能的函数，以下是简单的规则：

+
    +
  1. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
    2. +
  2. 括号里面可设置参数，参数不是必必需的(可有可无)，传入参数必须放在圆括号中间。
    3. +
  3. 函数的第一行语句可以选择性地（可有可无）使用文档字符串—用于存放函数使用说明。
    4. +
  4. 函数内容以冒号起始，并且缩进。
    5. +
  5. return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
    6. +
+

参数作用：增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据

+
    +
  1. 在函数内部，把参数当作变量使用，进行需要的数据处理
    2. +
  2. 函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递
    3. +
+

示例


#定义
def hello(s):
    '''this function is used to say hello,
    and exit.
    
    '''
    print('hello '+s)
    return
    
#调用
hello(s="omicsgene")

+ + +

不同类型参数的设置与使用

参数根据位置传递

如果我们设置了多个参数，python解释器会根据位置进行传递；

+

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

power(2,3)

power(x=2,n=3)

+ + +
必需参数

直接设定参数，没有给参数的默认值，函数调用时必需给参数传入值

+

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
    
power(4)
+ + + +
设置默认参数(函数调用时可有可无)

设置参数是可以设定参数的默认值，函数调用时可选给参数传入值们不给就是默认值。

+
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

def info(name, gender, age=6, city='Beijing'):
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)
+ + +
可变参数位置参数

* 在参数名字前面加一个星号，使参数成为一个可变参数，参数传入一个列表

+
def add(a,b):
    return a+b

def add1(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n 
    return sum
+ +
可变关键字参数

** 在参数名字前面加两个星号，使参数成为一个可变关键字参数，参数传入一个字典

+
def person(name, age, **kwargs):
    print('name:', name, 'age:', age, 'other:', kwargs)


#联合使用，参数如何传递？  
def foo(a,b,c=22,*args,**kwargs):
    print("a:",a,",","b:",b,",","c:",c,",","args:",args,",","kwargs:",kwargs)
+ +
强制 key=value形式传递

有个参数只有一个星号,表示星号后面的参数必须用（key=value）的形式进行传递参数，不能省略key。

+
def foo1(a,b,*,c=3):
    print(a,b,c)
    
def foo2(a,b,c=3):
    print(a,b,c)

foo1(1,2,4)
foo2(1,2,4)
+ + +
函数编写与调用注意事项
    +
  1. 必需参数一般写在前面，有默认值的参数紧随其后（位置参数）
    2. +
  2. 参数名省略时，注意位置
    3. +
+
def foo(a,b,c=22,*args,**kwargs):
    print(a,b,c,args,kwargs)

foo()
+ + + +

1.3 Python中匿名函数

有时候一个函数只是临时使用一下，以后就不会再使用了，要是用def定义比较麻烦。这个时候就可以用lambda来定义一个匿名函数

+
语法：

变量名= lambda [arg1[, arg2, … argN]]: expression

+
注意:
    +
  1. 参数：可选，通常以逗号分隔的变量表达式形式，也就是位置参数
    2. +
  2. 表达式中不能包含 循环，return
    3. +
  3. 可以包含 if…else…语句.
    4. +
  4. 表达式计算的结果直接返回
    5. +
+

# 使用lambda的表达式
lambda x, y: x + y

# 使用def定义的函数
def add( x, y ):
  return x + y

# lambda也允许有默认值和使用变长参数
lambda x, y = 2: x + y
lambda *z: z

# 调用lambda函数
a = lambda x, y: x + y
a(1, 3)

b = lambda x, y = 2: x + y
b(1)

b(1, 3)

c = lambda *z: z
c(10, 'test')


+ + + +

匿名函数应用

#自定义排序关键字

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2])            # 按年龄排序
sorted(students, key=lambda s: s[2], reverse=True)       # 按降序


#字典排序：


dic = {'a':2,'b':1}
#按照key排序
d = sorted(dic.items(), key = lambda k:k[0])

#按照values排序
 e = sorted(dic.items(), key = lambda k:k[1])


+

1.4 变量作用域

变量的作用域决定了在哪一部分程序你可以访问那个特定的变量名称。一个程序的所有的变量并不是在任何位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

+

两种最基本的变量作用域如下：

+
    +
  • 全局变量
    • +
  • 局部变量
    • +
+
全局变量和局部变量
    +

  • 定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

    +
    • +

  • 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

    +
    • +
+
total = 0; # 这是一个全局变量

def mysum( arg1, arg2 ):
   total = arg1 + arg2; # total在这里是局部变量.
   print("inside  ", total)
   return total
 
#调用mysum函数
mysum( 10, 20 )
print("global var ", total)
+ + +

1.5 变量传递给参数参数的可变性

函数的参数传递中传入可变数据和不可变数据会有不同：

+
    +
  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
    • +
  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
    • +
+
传不可变对象实例,传进去的变量不改变原变量
def ChangeInt(a):
    a = 10
 
b = 2
ChangeInt(b)
print (b) # 结果是 2
+ +
传可变对象实例,传进去的变量可改变原变量
def changeme(mylist):
   "修改传入的列表"
   mylist.append([1,2,3,4]);
   print("Inside value:", mylist)
   return
 
# 调用changeme函数
mynum = [10,20,30]
changeme(mynum)
print("Outside value:", mynum)
+ +
+

2 面向对象的编程与获取帮助

2.1 类和实例

+

面向对象最重要的概念就是类（Class）和实例（Instance），类描述了一组具有相同特性（属性）和相同行为（方法）的对象(Object)。面向对象的编程语言最大的特色就是可以编写自己所需的数据类型，以更好的解决问题。

+
+
+

必须牢记类是抽象的模板，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法或者属性，但各自的数据可能不同。

+
+

image

+

面向对象编程特点

面向对象编程(Object-oriented programming，缩写：OOP)的3个基本特征是：封装、继承、多态

+
    +

  • 封装：将属性和方法(数据和功能)封装在一起形成类。

    +
    • +

  • 继承：可以使用现有类的功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

    +
    • +

  • 多态：允许让父类的指针分别指向不同的子类, 调用不同子类的同一个方法, 会有不同的执行效果

    +
    • +
+

2.2 面向对象编程

定义一个类

类的组成
    +
  • 属性(对象的属性) ——变量：状态、静态的
    • +
  • 方法(对象的行为) ——函数：过程、动态的
    • +
+
类的方法与属性
+

在类的内部，使用 def 关键字来定义一个方法，类的方法与普通的函数只有一个特别的区别——他们的第一个参数必须是 self。

+
+
+

self代表类的实例，而非类。

+
+
构造方法

类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用。

+
#类的定义
class Car:
    '''this class define a car '''
    #类属性  共有属性
    wheels=4
    #构造方法
    def __init__(self, make, model, year):
        #成员属性
        self.make = make
        self.model = model
        self.year = year
        self.orometer_reading = 0
    #类方法
    def get_description(self):
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model+" "+str(self.wheels)
        return long_name
 
    def get_odometer(self):
        print("This car has "+ str(self.orometer_reading) + " miles on it")
 
    def increase(self,miles):
        self.orometer_reading +=miles

+ +

创建类的实例化对象，访问属性和使用方法

现在让我们新建一个对象my_car:

+
#类实例my_car
my_car = Car("yellow", "beetle", 1967)
#查看属性
print(f" My {my_car.color} car {my_car.model} is made in {my_car.year}")

#属性修改
my_car.color="black"

#对象方法调用

my_car.get_description()
my_car.increase(1000)
my_car.read_odometer()
my_car.update_orometer(20000)

#查看类或者实例所有的属性与方法
dir(my_car)
dir(Car)
+

2.3 Python 类定义中的特殊属性与方法

Python中用下划线作为变量前缀和后缀指定特殊变量

+
    +
  • _xxx 不能用’from module import *’导入
    • +
  • __xxx 类中的私有变量名
    • +
  • __xxx__ 系统定义的名字
    • +
  • 核心风格：避免用下划线作为变量名的开始。
    • +
+

因为下划线对解释器有特殊的意义，而且是内建标识符所使用的符号，我们建议程序员避免用下划线作为变量名的开始。

+

==一般来讲，变量名_xxx被看作是“私有的”，在模块或类外不可以使用。==

+

当变量是私有的时候，用_xxx 来表示变量是很好的习惯。因为变量名__xxx__对Python 来说有特殊含义，对于普通的变量应当避免这种命名风格。

+
    +
  • “单下划线” 开始的成员变量叫做保护变量，意思是只有类对象和子类对象自己能访问到这些变量；
    • +
  • “双下划线” 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。
    • +
+
Python类的特殊属性
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
属性含义
__class__对象或类所属的类
__name__类、函数、方法等的名字
__dict__类的属性 以key-value形式展示的字典，展示出属性所对应的值
__module__类定义所在的模块名称
__doc__类、函数的文档字符串，如果没有定义则为None
+
#print(my_car.__name__)
print(my_car.__doc__)
print(my_car.__dict__)
print(my_car.__module__)
print(my_car.__class__)


print(Car.__name__)
print(Car.__doc__)
print(Car.__dict__)
print(Car.__module__)
print(Car.__class__)
+ + + +
Python类特殊方法
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法功能说明
__new__()类的静态方法，用于确定是否创建对象
__init__()构造函数，生成对象时调用
__dir__返回类或者对象的所有方法与属性，dir()操作实例就是调用
__del__()析构函数，释放对象时调用
__add__()+
__sub__()-
__mul__()*
__truediv__()/
__floordiv__()//
__mod__()%
__pow__()**
__repr__()打印,转换
__setitem__()按照索引赋值
__getitem__()按照索引获取值
__len__()计算长度
__call__()函数调用
__contains__()in
__eq__()==
__ne__()!=
__lt__()<
__le__()<==
__gt__()>
__ge__()>=
__str__()转换为字符串
__shift__(), __rshift__()<<, >>
__and__(), __or__()&,
__invert__(), __xor__()~, ^
__iadd__(), __isub__()+=, -=
+
例子：实现特殊方法__repr__：

## __repr__
class Person:
    def __init__(self, name):
        self.name = name
    def __repr__(self):
        return "hello %s." % self.name

 p = Person('hkey')

 p
 print(p)

+ +

定义了__repr__方法，不管是直接打印对象还是通过print打印对象，都是走的__repr__中定义的格式。

+

更多类的特殊方法了解：https://www.omicsclass.com/article/1033

+

2.4 类的继承 (选修)

#类定义
class people:
    #定义属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    #定义类方法
    def speak(self):
        print("%s speak: I am %d years old." %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s speak: I am %d years old， I am in %d grade of primary school."%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()
+

2.5 Python获取帮助

Python 官方中文帮助

https://docs.Python.org/zh-cn/3.7/

+

编辑器提供帮助

pycharm中的documentation内置显示（默认快捷键为Ctrl+Q），选中函数，Ctrl+Q如下：

+

也有External documetation，快捷键为Shift+F1

+

陌生类获取类的属性和方法

dir()函数主要用来查看对象的属性和方法，再去了解这些属性和方法，学习类的使用。

+

__doc__属性查看帮助文档

任务答案

+
a = [1,2,3]
a.reverse.__doc__
+ + +

==任务答案：==

+
def my_abs(x):
    a=0
    if x>=0:
        a=x
    else:
        a=0-x
    return a
    
my_abs(-100)
+ + +
+

3 Python 标准库中包的使用

python标准库帮助地址：https://docs.python.org/zh-cn/3.7/library/index.html

+

3.1 包常见导入方法


# 1 直接导入
import os
import time
import sys
import os,time,sys,re  #每个包之间用逗号隔开；

#导入的同时改名字
import sys as system


#2 导入指定的方法，模块等

#导入包里面的指定的函数或者类
from os import path
from os import path, walk, unlinkfrom

#导入包里面所有的内容
from os import *

+ +

这些导入的包，其实就是别人写好的代码文件(*.py)，我们导入到我们的程序中就可以直接使用里面的方法，函数，类等，省去自己编写代码的麻烦。如果了解Python包导入的机制，自己也可以写一些包，共享给别人，提供代码的复用性，从而提高我们的开发效率。

+

3.2 Python 自定义模块导入讲解

模块搜索路径

导入过程首先需要定位导入文件的位置，也就是，告诉Python到何处去找到要导入的文件，因此，需要设置模块的搜索路径。在大多数情况下，Python会自动到默认的目录下去搜索模块；如果要在默认的目录之外导入模块，就需要知道Pyhon搜索模块路径的机制。

+

Python搜索模块的路径是由四部分构成的：==程序的主目录、PATHONPATH目录、标准链接库目录和.pth文件的目录，这四部分的路径都存储在sys.path 列表中。==

+
1， 程序的主目录

主目录是指程序所在的目录，Python首先会到主目录中搜索模块。

+

因为主目录总是第一个被搜索，如果模块完全处于主目录中，所有的导入都会自动完成，而不需要单独配置路径。

+
2，PATHONPATH目录

PythonPATH目录是指PythonPATH环境变量中配置的目录，是第二个被搜索的目录，Python会从左到右搜索PythonPATH环境变量中设置的所有目录。

+
3，标准链接库目录

标准链接库目录是Python按照标准模块的目录，是在安装Python时自动创建的目录，通常不需要添加到PythonPATH目录中。例如：

+
4，路径文件（.pth文件）

在模块搜索目录中，创建路径文件，后缀名为.pth，该文件每一行都是一个有效的目录。Python会读取路径文件中的内容，每行都作为一个有效的目录，加载到模块搜索路径列表中。简而言之，当路径文件存放到搜索路径中时，其作用和PYT)HONPATH环境变量的作用相同。

+

3.3 导入自定义模块指定路径的方法

方法1：简单不用操作

把自己写的模块，复制到自己的程序同级目录就可以直接导入；

+
方法2: 函数添加 （临时添加）
    +
  1. import sys
    2. +
  2. 查看sys.path
    3. +
  3. 添加sys.path.append(“D:\\perl_script”)
    4. +
+
方法3: 增加.pth文件，推荐！ （永久添加）
    +

  • 在site-packages目录添加一个文件如mypkpath.pth，必须以.pth为后缀，文件内写上你要加入的模块文件所在的路径，可以添加多行。

    +
    • +

  • 如果运行在Windows和Python3.0中，如果Python安装目录的顶层是C:\Users\Administrator\AppData\Local\Programs\Python\Python37，那么可以把自定义的路径文件 mypath.pth 放到该目录中。

    +
    • +

  • 也可以放到标准库所在位置的site-packages子目录中（C:\Users\Administrator\AppData\Local\Programs\Python\Python37\Lib\site-packages），来扩展模块的搜搜路径。

    +
    • +
+
方法4: 修改环境变量 （永久添加）
    +
  • windows用户可以修改系统环境变量 PYTHONPATH
    • +
  • linux用户也可以添加环境变量 PYTHONPATH
    • +
+

练习：

导入自己写的一个模块：

+

把以下内容存储到文件cars.py中，然后用import导入该模块：

+

CAR_num=11

make=["Ford","Rolls-royce","Volkswagen"]

def mysum( arg1, arg2 ):
   total = arg1 + arg2; # total在这里是局部变量.
   print("inside  ", total)
   return total;


def das_auto(make="Volkswagen", model="Magotan", year=2019):
    '''this function is used to create Volkswagen car'''
    my_car=Car("Volkswagen","Magotan",2019)
    return my_car


#类的定义
class Car:
    '''this class define a car '''
    #类属性  共有属性
    wheels=4
    #构造方法
    def __init__(self, make, model, year):
        #成员属性
        self.make = make
        self.model = model
        self.year = year
        self.orometer_reading = 0
    #类方法
    def get_description(self):
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model+" "+str(self.wheels)
        return long_name
 
    def read_odometer(self):
        print("This car has "+ str(self.orometer_reading) + " miles on it")
 
    def update_orometer(self,miles):
        if miles >= self.orometer_reading:
            self.orometer_reading = miles
        else:
            print("You can'troll back an odometer")
 
    def increase(self,miles):
        self.orometer_reading +=miles

+ +
==小知识== 模块和包的区别

（1）模块：是一个单独的.py文件，用于存放一些功能相关的代码，可以是代码更加容易维护，提高代码的重用价值

+

（2）包：是一个有层级的目录结构，包含n个模块或者n个子包，包中一定要有__init__.py文件

+

3.4 Python中 os sys time math包的学习

os 常用方法

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法说明
os.getcwd()得到当前工作目录，即当前Python脚本工作的目录路径。
os.mkdir()方法用于以数字权限模式创建目录，
os.listdir(path)返回指定目录下的所有文件和目录名。
os.walk()方法用于通过在目录树中游走输出在目录中的文件名，向上或者向下。
os.remove(path)方法用来删除一个文件。如果指定的路径是一个目录，将抛出OSError，在Unix, Windows中有效
os.rmdir(path)方法用于删除指定路径的目录。仅当这文件夹是空的才可以, 否则, 抛出OSError。
os.system(command)函数用来运行shell命令。
os.linesep字符串给出当前平台使用的行终止符。例如，Windows使用’\r\n’，Linux使用’\n’而Mac使用’\r’。
os.sep可以取代操作系统特定的路径分隔符。windows下为 “\\”,linux 下为”/“
os.chdir(dirname)改变工作目录到dirname
os.path.isfile(path)方法分别检验给出的路径是否一个文件，输入路径必须是绝对路径。
os.path.isdir(path)方法检验给出的路径是否一个目录，输入路径必须绝对路径。
os.path.exists()方法用来检验给出的路径是否真地存在
os.path.join(path,name)连接目录与文件名或目录;使用“\”连接
os.path.basename(path)返回文件名
os.path.dirname(path)返回文件路径
os.path.abspath(name)获得绝对路径
os.path.getsize(name)获得文件大小
os.path.split(path)将path分割成目录和文件名二元组返回。
os.path.splitext()分离文件名与扩展名
+

包使用示例代码

#遍历一个目录，获得所有文件的路径

import os  
os.chdir("D:\Python_script")
cwd = os.getcwd()  
for dir_path, dir_names, file_names in os.walk(cwd): 
    for file_name in file_names:    
        p=os.path.join(dir_path,file_name)
        print(p)
    for dir_name in dir_names:
        p=os.path.join(dir_path,dir_name)
        print(p)


#windows系统中调用命令
os.system('copy a.v b.v')
os.system('del b.v')
os.system('rename a.v b.v')


#linux系统中调用命令
os.system('cp a.v b.v')
os.system('rm b.v')
os.system('mv a.v b.v')

+ + +

sys包常用属性或者方法

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法说明
sys.argv命令行参数List，第一个元素是程序本身路径
sys.exit(n)退出程序，正常退出时exit(0)
sys.version获取Python解释程序的版本信息
sys.modules返回系统导入的模块字段，key是模块名，value是模块
sys.path返回模块的搜索路径，初始化时使用PythonPATH环境变量的值
sys.stdout标准输出
sys.stdin标准输入
sys.stderr错误输出
+

math 常用属性和方法

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
方法说明示例
math.e自然常数e>>> math.e
math.pi圆周率pi>>> math.pi
math.log10(x)返回x的以10为底的对数>>> math.log10(2)
math.pow(x, y)返回x的y次方>>> math.pow(5,3)
math.sqrt(x)返回x的平方根>>> math.sqrt(3)
math.ceil(x)返回不小于x的整数>>> math.ceil(5.2)
math.floor(x)返回不大于x的整数>>> math.floor(5.8)
math.fabs(x)返回x的绝对值>>> math.fabs(-5)
+
+

练习：
将文件打开然后，批量的合并到一个文件中

+
fw=open("all.fa","w")
for i in os.listdir(os.getcwd()):
    if i.endswith("fa"):
        f=open(i,"r")
        for line in f:
            fw.write(line)
        f.close()
fw.close()
+ + +

4 正则表达式：

4.1 了解正则表达式

正则表达式是用于处理字符串（String）的强大工具，拥有自己独特的语法以及一个独立的处理引擎，效率上可能不如str自带的方法，但功能十分强大。得益于这一点，在提供了正则表达式的语言里，正则表达式的语法都是一样的，区别只在于不同的编程语言实现支持的语法数量不同；

+

正则表达式功能

    +
  • 查找/匹配
    • +
  • 替换
    • +
  • 捕获
    • +
  • 计数
    • +
+

正则表达式通配符

    +
  • 通配符是特殊字符，在正则表达式中有特殊意义
    • +
  • 直接的单词或者数字是原样匹配
    • +
+

常见通配符学习

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
模式匹配通配符描述
^匹配字符串的开头
$匹配字符串的末尾。
.匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[…]用来表示一组字符,单独列出：[amk] 匹配 ‘a’，’m’或’k’，[a-zA-Z0-9]
[^…]不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
\w匹配字母数字及下划线
\W匹配非字母数字及下划线
\s匹配任意空白字符，等价于 [\t\n\r\f].
\S匹配任意非空字符
\d匹配任意数字，等价于 [0-9].
\D匹配任意非数字
*匹配0个或多个的表达式,如:be*: b, be,beeeee, bee。
+匹配1个或多个的表达式,如: be+ : be,beeeee, bee。
?匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式 .如 bo? 只能匹配：b,bo
{ n}精确匹配 n 个前面表达式。例如， o{2} 不能匹配 “Bob” 中的 “o”，但是能匹配 “food” 中的两个 o。
{ n,}匹配 n 个前面表达式。例如， o{2,} 不能匹配”Bob”中的”o”，但能匹配 “foooood”中的所有 o。”o{1,}” 等价于 “o+”。”o{0,}” 则等价于 “o*”。
{ n, m}匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
|或者的意思，如：a| b 匹配a或b
()对正则表达式分组并记住匹配的文本,正则表达式捕获功能
+
选修内容
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
模式匹配通配符描述
(?imx)正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)类似 (…), 但是不表示一个组
(?imx: re)在括号中使用i, m, 或 x 可选标志
(?-imx: re)在括号中不使用i, m, 或 x 可选标志
(?#…)注释.
(?= re)前向肯定界定符。如果所含正则表达式，以 … 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)匹配的独立模式，省去回溯。
\A匹配字符串开始
\Z匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z匹配字符串结束
\G匹配最后匹配完成的位置。
\b匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配”never” 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。
\B匹配非单词边界。’er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。
\n, \t, 等.匹配一个换行符。匹配一个制表符。等
\1…\9匹配第n个分组的内容。
\10匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。
+

4.2 正则表达式实操学习

https://regexone.com/

+

正则表达式练习

    +
  • 应用 notepad++ 或者editplus 软件 正则表达式处理文本
    • +
  • 不足之处->无法处理大文件（内存限制）
    • +
+
练习要求：
    +
  • 处理要求1：把序列转换成一行；
    • +
  • 处理要求2：把一行的序列文件再转换回来；
    • +
+

处理文件内容示例：

+
>NP_651973.4 nbs, isoform E [Drosophila melanogaster]
MFVLTKDDEKFVLFPGKKVYTIGRLATDLIVAQDLSISRNHAQLLIQTEADGDDTLHIEDLGSRYGTFIF
PKNSQKPRKVPAKTSTPLPVGTRLRFGANMSIWQVTQLKLVTTVSALTRSEVQELTKMLEPMGGTVTSNW
TEECSHLTMNEVSVTVKLLHAMLENKPIVTFPYWRKMLQAAQSIHVKEGWPQPEDYQPTNIDVTWRPERT
RLFAGKTFVFMNRKHFDMYGSVVQKAGATCKDINSGVRKTFLTKSDVIVIQYVPSSQSQATESINSIQDR
YILEQNGRRIIQEYEIGMALIHCSITEFCNPTHKFISDSLPTTESVTSSMAFNSSIIVPNTERHSAQSNA
TPISELVVPESIECEMEQDASKPHSEDQASLRKRSHASTVDSSDEEKKSTLSKRAKSDIATKLTMKSKNA
ILLDSSLEEDVTPAPAPAPVQRVTRQSKAIAEEKSVHPPVPAASKHITRKTKQVFCVDSSDEENENARKP
KETPAPTIPSMAKKKTEAPVATRISPRLNGKSLATNITNQPADKHAVPAKRPVLSVASSDEEDEGDLFQF
RKSPQKPAETVVQPRIAGKGNAPARISVVDFLEKSQAQEPAPVPPQLESQSQTQPRKRLRLELLNESDSD
DCDNLFNFADSKKKRKTQEAQRNDDSTDGLFNFNSERPSDHDDEDSRLTEPFVPETESKKQSKYIVAPRR
DRPKKVDISGWLSCSRLNDNIKSEIDADSVKMETSIKADPDEEQWLAAMKDSIEVRMCNLNIVIRSQEEV
DASLEDSVNKHGGRKNFKKFVKTKNPHPQKRIVALKSLRLADGMVTCV

>AIQ85043.1 NBS-LRR disease resistance protein, partial [Musa ABB Group]
MGGVGKTTLAQQAYNPERVKDYFHHKVWVCVSDNFNVERLSKEIIESITENKCDLSNLDTLQVVVKKKLT
SKRFLLVLDDVWNEDSLKWERFCAPLRYGEPGSKILVTTRSKKIAEMVGNPFPLGGLDEASYWKLFKKCA
FGSEYAGE

>AIQ85044.1 NBS-LRR disease resistance protein, partial [Musa laterita]
GGGGKTSLAQQAYNHERVKDYFHHKVWVCVSDNFNVERLTKEIIESLTRNKWDLNNLDTLQVVVKEELTS
KRFLLVLDDVWNEDSLKWERFCAPLRYGEPGSKILVTTRSKKIAEMVGNPIPLGGLDEASYWELFKKCAF
GSEDAGE

>AIQ85045.1 NBS-LRR disease resistance protein, partial [Musa laterita]
MGGVGKTTLAQQAYNHERVQDYFQHEVWVCVSDNFNVERLTKEIIESITENKCDLSNLDTLQVVLKKNLT
SKRFLLVLDDVWNEDSLKWERFCAPLRYGEPGSKILVTTRSKNVFENGWNPIPLGGLDEASYWKLFKKCA
FGSEDAGEFPHLE

>AAM28915.1 NBS, partial [Pinus taeda]
TRFDWKEQLHRLQHVLPSETQEKLXFGYLNLNREERQMFLDSACFFIGQKRDTAIRIWEGSLWDGHSGFL
TLQHRCLLGVDDENNIEXHDHLRDFGRAACPNRFLPSWIPMDSLRVLQVSGSVLKTLWEDDSQPPLQLRE
LEINAPLSNIPGSIGRLKHLERFVVGKYLSGQVNLTELPVEFCHLQSLKALVLTECSKIKSLPEFGALLM
WLRHIDLSFCRNLERLPDSLHYLSHLRLINLSDCHDLVTLPDNIGRLRCLQHIDLQGCHNLERLPDSFGE
LTDLRHINLSGCHDLQRLPDSFGKLRYLQHIDLHGCHSLEGLPISFGDLMNLEYINLSNCHNLERLPESI
GNLSDLRHIDLSGCHNLERLPDNFRELEELRYLDVEGCSNLIIDRFEIIGISDNLPVAHQVNWNKY

+ +

4.3 Python中正则表达式re包

==新包学习思路总结：==

+
    +
  1. 学习里面的函数/方法
    2. +
  2. 类实例化后对象的学习(方法，属性)
    3. +
  3. 都有哪些类，类之间的关系
    4. +
+

re包中常用方法

    +
  1. re.search(pattern, string, flags=0)
    2. +
  2. re.match(pattern, string, flags=0)
    3. +
  3. re.findall(pattern, string, flags=0)
    4. +
+

参数说明

+
    +
  • pattern 匹配的正则表达式
    • +
  • string 要匹配的字符串。
    • +
  • flags 用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。见：正则表达式修饰符
    • +
+

注意区别：

re.match与re.search的区别
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

+

re.match和re.search 与findall的区别：
前面两个找到一个就结束，findall会找到所有。
返回对象不同，findall返回列表，

+

正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
修饰符描述
re.I忽略大小写
re.M多行匹配，影响 ^ 和 $
re.U根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.L做本地化识别（locale-aware）匹配
re.S使 . 匹配包括换行在内的所有字符
re.X该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
+

代码示例：

+
import re
 
line = "Cats are smarter than dogs"
 
matchObj = re.match( r'dogs', line, re.I)
if matchObj:
   print("match --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")


line = "Cats are smarter than Dogs"
matchObj = re.search( r'dogs', line, re.I)
if matchObj:
   print ("search --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")
+ + + +

匹配对象的方法 得到详细的搜索匹配结果

    +
  • group() 返回被 RE 匹配的字符串。
    • +
  • start() 返回匹配开始的位置
    • +
  • end() 返回匹配结束的位置
    • +
  • span() 返回一个元组包含匹配 (开始,结束) 的位置
    • +
+

更多方法及帮助：https://docs.python.org/zh-cn/3.7/library/re.html#match-objects

+
import re


line = "Cats are smarter than dogs";
 
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
 
if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"
   
   
print(re.search('www', 'www.omicsclass.com').span())  # 在起始位置匹配
print(re.search('com', 'www.omicsclass.com').span())         # 不在起始位置匹配
+ + +

搜索替换

Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。支持正则表达式，比字符串自带的replace方法功能更强大。

+

语法：

+
+

re.sub(pattern, repl, string, count=0, flags=0)

+
+
    +
  • pattern : 正则中的模式字符串。 (搜索的内容)
    • +
  • repl : 替换的字符串，也可为一个函数。 (替换的内容)
    • +
  • string : 要被查找替换的原始字符串。 (在哪里搜索替换)
    • +
  • count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
    • +
  • flags 用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。见：正则表达式修饰符
    • +
+
import re
 
tel = "010-8054-3251,www.omicsclasss.com"

# 删除字符串中的 数字 
num = re.sub(r"^\d+-\d+-\d+,", "", tel)
print("Website is:", num)
 
# 删除数字
num = re.sub(r'\d+', "", tel)
print("telphone num : ", num)



### 高级用法 （选修）
#repl 参数是一个函数
#以下实例中将字符串中的匹配的数字乘以 2：

# 将匹配的数字乘以 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
 
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))
+

re.split 方法支持正则表达式：

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：

+
+

re.split(pattern, string[, maxsplit=0, flags=0])

+
+
    +
  • pattern 匹配的正则表达式
    • +
  • string 要分割的字符串。
    • +
  • maxsplit 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
    • +
  • flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
    • +
+
import re
re.split(r'[,;=]', 'omicsclass, omicsclass;omicsclass.')
re.split(r'\s+', ' omicsclass, omicsclass, omicsclass.') 
re.split(r',', ' omicsclass, omicsclass, omicsclass.', 1) 

 
re.split(r'\t', 'hello world')   # 对于一个找不到匹配的字符串而言，split 不会对其作出分割
['hello world']

+ + +

re.compile 方法

compile 方法用于编译正则表达式，提前编译后的正则表达式可以加快正则表示的匹配速度；编译后生成一个正则表达式（ Pattern ）对象。

+

语法格式为：

+
+

re.compile(pattern[, flags])

+
+
    +
  • pattern : 一个字符串形式的正则表达式
    • +
  • flags 用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。见：正则表达式修饰符
    • +
+
Pattern正则表达式对象 （正则对象）

常见方法：

+
    +
  • Pattern.findall(string[, pos[, endpos]])
    • +
  • Pattern.search(string[, pos[, endpos]])
    • +
  • Pattern.match(string[, pos[, endpos]])
    • +
+

参数：

+
    +
  • string : 待匹配的字符串。
    • +
  • pos : 可选参数，指定字符串的起始位置，默认为 0。
    • +
  • endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。
    • +
+

注意： match 和 search 是匹配一次 findall 匹配所有。

+

更多方法：https://docs.python.org/zh-cn/3.7/library/re.html#regular-expression-objects

+
import re
 
p = re.compile(r'\d+')   # 查找数字
result1 = p.findall('omicsclass 123 google 456')
result2 = p.findall('runomicsclass123google456', 0, 10)
 
print(result1)
print(result2)



result3=p.search("runomicsclass123google456")
result4=p.match("runomicsclass123google456")

print(result3)
print(result4)

#或者也可以这样用
result5=re.search(p,"runomicsclass123google456")
result6=re.match(p,"runomicsclass123google456")

print(result5)
print(result6)
+ + + +

正则表达式处理文件主要用处

    +
  1. split分隔文件
    2. +
  2. 查找是否含有某某字符，配合IF判断
    3. +
  3. 在字符串中捕获信息
    4. +
+

练习

从GFF文件中提取基因ID及位置信息存成表格(注意用正则表达式的捕获功能完成)

+

GFF 文件（人1号染色体上基因注释信息）地址：ftp://ftp.ensembl.org/pub/release-98/gff3/homo_sapiens/Homo_sapiens.GRCh38.98.chromosome.1.gff3.gz

+

答案：

+
import re

fr=open("D:\\python_script\\Homo_sapiens.GRCh38.98.chromosome.1.gff3\\Homo_sapiens.GRCh38.98.chromosome.1.gff3","r")

fw=open("D:\\python_script\\chr1.txt","w")

for line in fr:
    if re.match("#",line):
        continue
        
    tmp=re.split("\t",line)
    if tmp[2] == "gene":
        mobj=re.search("ID=gene:([^;]+)",tmp[8]) #捕获基因ID
        if mobj:
            fw.write("\t".join([tmp[0],tmp[3],tmp[4],tmp[6],mobj.group(1)])+"\n")
            
fr.close()
fw.close()
+ + +
+

5 Python biopython包处理生物数据

5.1 BioPython包

image

+

专门用于处理生物数据的包，主要功能如下：

+

（1）biopython处理生物数据

    +
  • Blast output – both from standalone and WWW Blast
    • +
  • Clustalw
    • +
  • FASTA/FASTQ
    • +
  • GenBank
    • +
  • PubMed and Medline
    • +
  • ExPASy files, like Enzyme and Prosite
    • +
  • SCOP, including ‘dom’ and ‘lin’ files
    • +
  • UniGene
    • +
  • SwissProt
    • +
+

（2）在线链接生物数据库，实时处理数据

    +
  • NCBI – Blast, Entrez and PubMed services
    • +
  • ExPASy – Swiss-Prot and Prosite entries, as well as Prosite searches
    • +
+

（3）与生物信息常用软件交户，实现批量处理分析数据

    +
  • Standalone Blast from NCBI
    • +
  • Clustalw alignment program
    • +
  • EMBOSS command line tools
    • +
+

获取帮助：

官方网站：https://biopython.org/

+

帮助文档：http://biopython.org/DIST/docs/tutorial/Tutorial.pdf

+

中文帮助文档（Last Update – 22 March 2013 (Biopython 1.61+)）：https://biopython-cn.readthedocs.io/zh_CN/latest/

+

安装

pip install biopython -i  https://pypi.tuna.tsinghua.edu.cn/simple #安装
pip install --upgrade biopython  #更新
pip uninstall biopython  #卸载

#导入包：
import Bio
+

5.2 利用biopython处理序列(fasta，fastq等)

Seq序列对象与SeqRecord注释对象学习

Seq对象中文帮助： https://biopython-cn.readthedocs.io/zh_CN/latest/cn/chr03.html#chapter-bio-seq

+

SeqRecord注释对象中文帮助： https://biopython-cn.readthedocs.io/zh_CN/latest/cn/chr04.html#chapter-seqrecord

+

5.2.1 Seq序列对象

from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio.Alphabet import IUPAC
from Bio.SeqUtils import GC

#Seq 对象创建
dna_seq = Seq("AGTACACTGGT", IUPAC.unambiguous_dna)
protein_seq = Seq("EVRNAK", IUPAC.protein)

#序列对象继承了字符串对象一些方法
len(dna_seq)
dna_seq.count("A")
GC(dna_seq)  #计算GC含量
dna_seq[4:12] #切取序列
str(dna_seq)  #将序列对象转换成字符串
my_seq = Seq("ACGT", IUPAC.unambiguous_dna)
my_seq + dna_seq  #连接或添加序列
my_seq.upper()  
my_seq.lower()

#核苷酸序列反向互补序列            
my_seq.reverse_complement()  

#转录
coding_dna = Seq("ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG", IUPAC.unambiguous_dna)
messenger_rna = coding_dna.transcribe()
messenger_rna.back_transcribe()  #从mRNA逆向转录为DNA编码链的方法

#翻译  https://biopython-cn.readthedocs.io/zh_CN/latest/cn/chr03.html#sec-translation
coding_dna.translate()

+ + +

Bio.Alphabet.IUPAC 提供了蛋白质、DNA和RNA的基本定义：

+
    +
  • IUPAC.protein 蛋白质
    • +
  • IUPAC.unambiguous_dna DNA
    • +
+

更多编码见：https://www.omicsclass.com/article/409

+

5.2.2 SeqRecord序列注释对象

SeqRecord 类非常简单,包括下列属性:

+

.seq
– 序列自身（即 Seq 对象）。

+

.id
– 序列主ID（-字符串类型）。通常类同于accession number。

+

.description
– 序列描述（-字符串类型）。

+

.name
– 序列名/id （-字符串类型）。 可以是accession number, 也可是clone名（类似GenBank record中的LOCUS id）。

+

.letter_annotations
– 对照序列的每个字母逐字注释（per-letter-annotations），以信息名为键（keys），信息内容为值（value）所构成的字典。值与序列等长，用Python列表、元组或字符串表示。.letter_annotations可用于质量分数(如第 18.1.6 节) 或二级结构信息 (如 Stockholm/PFAM 比对文件)等数据的存储。

+

.annotations
– 用于储存附加信息的字典。信息名为键（keys），信息内容为值（value）。用于保存序列的零散信息（如unstructured information）。

+

.features
– SeqFeature 对象列表，储存序列的结构化信息（structured information），如：基因位置, 蛋白结构域。

+

.dbxrefs
– 储存数据库交叉引用信息（cross-references）的字符串列表。

+

SeqRecord对象创建

from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio.Alphabet import IUPAC

simple_seq = Seq("CCCTTCTTGTCTTCAGCGTTTCTCC", IUPAC.unambiguous_dna)
simple_seq_r = SeqRecord(simple_seq, id="AC12345",description="just a test sequence")

#属性后添加和修改
simple_seq_r.description = "just a test sequence"

simple_seq_r.seq
simple_seq_r.id
simple_seq_r.description

#如果是fastq文件，可以添加序列质量值注释信息

simple_seq_r.letter_annotations["phred_quality"] = [26, 26, 18, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 22, 26, 26, 26, 26,
26, 26, 26, 23, 23]
print(simple_seq_r.letter_annotations)
print(simple_seq_r.letter_annotations["phred_quality"])


#序列截取：

simple_seq_r[0:2]

+ +

SeqRecord对象从文件中获得

fasta/fastq文件读写，得到SeqRecord对象；

+
#fasta文件读取得到SeqRecord对象
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os

os.chdir("D:\\python_script")
output_handle = open("out.fa", "w")
for rec in SeqIO.parse("test.fa", "fasta"):
    seq=rec.seq
    seq_r = SeqRecord(seq[0:10],id=rec.id,description=rec.description)
    SeqIO.write(seq_r, output_handle, "fasta")

output_handle.close()
+

5.3 练习

任务：利用biopython处理fasta/fastq序列
    +
  1. 任务: 提取指定ID的fasta序列
    2. +
  2. 任务: 截取fasta序列中指定位置的序列
    3. +
  3. 任务: fastq文件转换成fasta文件
    4. +
  4. 任务: fastq文件去掉前5个碱基
    5. +
+

fa文件：

+
>AT1G66550.1 cds chromosome:TAIR10:1:24828537:24829589:1 gene:AT1G66550 gene_biotype:protein_coding transcript_biotype:protein_coding gene_symbol:WRKY67 description:Probable WRKY transcription factor 67 [Source:UniProtKB/Swiss-Prot;Acc:Q93WV7]
ATGGTTTCCAACATTGATCACAAGGCTATGGAAGCACTCCTCCGTGGCCAAGGATGCGCT
AACAACCTCAAGATTCTCCTTGAAAACGGCGAAATAAGCTCAGTTTCAACAGAACCACTC
ATCCACACCATTCTCGATTCTTTCTCACTTGCTCTGTCTTTTATGGATTCTCCTAATCAT
CCACCATACCATGAATCCTCTTCTCATAACATGGCAAGTCATATGTCCCGGAGATCATCT
AAGCAAGTACAACATCGCAGAAAACTTTGTGTAGCAGAAGGTTTAGTGAATTACAATCAC
GATTCCCGGACTATGTGCCCCAATGATGGCTTCACCTGGAGGAAATATGGACAAAAAACC
ATTAAAGCCTCAGCGCACAAAAGGTGTTACTATCGGTGTACCTATGCAAAAGACCAAAAC
TGCAATGCTACAAAGCGGGTGCAGAAGATCAAAGACAACCCTCCAGTGTACAGAACCACT
TACTTGGGAAAACATGTGTGTAAAGCTTTTGCAGTTCATGATGATACATATAGTTCCACG
ATGATTCGATTCGACCAAGTTGTTCCTGAACCGATTATGCCGCAGCTCACAACAATTGAC
CACCAAGTAATTACCGTGGAGGAAAACTCCGCAGAACATATCATGAACCAAGAATGTGAT
ATTAATGATTATTTGGTGGATGATGACCCATTTTGGGCTAGTCAATTTCCCCCGTTTCCA
TCGAGTGACACAATGTTCTTGGAAAACATTTCTGCTTTTGATTAG
>AT4G39410.1 cds chromosome:TAIR10:4:18332606:18334893:-1 gene:AT4G39410 gene_biotype:protein_coding transcript_biotype:protein_coding gene_symbol:WRKY13 description:WRKY13 [Source:UniProtKB/TrEMBL;Acc:A0A178UV80]
ATGGGTGCGATAAACCAAGGAATAAGCTTGTTTGATGAATCACAAACCGTCATAAACCCT
ATTAATACCAACCATCTAGGTTTCTTCTTCTCTTTCCCTAGTCACAGCACCTTATCTTCA
TCATCTTCGTCGTCTTCGTCTTCTCCTTCTTCTCTTGTGTCTCCATTTCTTGGTCATAAC
TCCCTAAACTCCTTCCTTCATAATAACCCGTCTTCATTCATAAGTCATCCTCAAGATTCC
ATCAATCTCATGACCAATCTCCCCGAAACCCTAATCTCGTCTTTGTCCTCATCAAAGCAA
AGGGACGATCATGATGGTTTTCTTAATCTCGATCATCATCGTCTTACCGGTAGTATTTCA
TCCCAAAGACCCCTGTCAAATCCATGGGCATGGAGTTGTCAAGCGGGATACGGAAGCAGC
CAGAAAAACAACCATGGAAGCGAGATTGATGTTGATGATAATGATGATGAGGTTGGCGAT
GGTGGTGGCATTAATGATGATGATAATGGTCGTCATCATCATCATGATACTCCCAGTCGT
CATGATAAACATAACACAGCGTCATTAGGCGTAGTTTCTTCTCTGAAGATGAAGAAGCTT
AAGACAAGAAGAAAAGTGAGGGAACCTCGGTTTTGCTTTAAGACACTTAGCGAGGTTGAT
GTCTTAGATGATGGATATAGATGGAGAAAGTATGGCCAGAAAGTTGTCAAAAACACCCAA
CATCCCAGGAGCTATTACAGATGCACACAAGACAAGTGTAGAGTGAAGAAGAGAGTGGAG
AGATTAGCAGATGACCCAAGAATGGTAATCACTACTTACGAAGGAAGACACCTTCACTCT
CCTTCTAATCATCTCGACGACGACTCTCTCTCCACCTCTCACCTGCACCCTCCTCTCTCC
AACTTCTTCTGGTGA
>AT4G18170.1 cds chromosome:TAIR10:4:10061214:10062893:1 gene:AT4G18170 gene_biotype:protein_coding transcript_biotype:protein_coding gene_symbol:WRKY28 description:WRKY28 [Source:UniProtKB/TrEMBL;Acc:A0A178V3M3]
ATGTCTAATGAAACCAGAGATCTCTACAACTACCAATACCCTTCATCGTTTTCGTTGCAC
GAAATGATGAATCTGCCTACTTCAAATCCATCTTCTTATGGAAACCTCCCATCACAAAAC
GGTTTTAATCCATCTACTTATTCCTTCACCGATTGTCTCCAAAGTTCTCCAGCAGCGTAT
GAATCTCTACTTCAGAAAACTTTTGGTCTTTCTCCCTCTTCCTCAGAGGTTTTCAATTCT
TCGATCGATCAAGAACCGAACCGTGATGTTACTAATGACGTAATCAATGGTGGTGCATGC
AACGAGACTGAAACTAGGGTTTCTCCTTCTAATTCTTCCTCTAGTGAGGCTGATCACCCC
GGTGAAGATTCCGGTAAGAGCCGGAGGAAACGAGAGTTAGTCGGTGAAGAAGATCAAATT
TCCAAAAAAGTTGGGAAAACGAAAAAGACTGAGGTGAAGAAACAAAGAGAGCCACGAGTC
TCGTTTATGACTAAAAGTGAAGTTGATCATCTTGAAGATGGTTATAGATGGAGAAAATAC
GGCCAAAAGGCTGTAAAAAATAGCCCTTATCCAAGGAGTTACTATAGATGTACAACACAA
AAGTGCAACGTGAAGAAACGAGTGGAGAGATCGTTCCAAGATCCAACGGTTGTGATTACA
ACTTACGAGGGTCAACACAACCACCCGATTCCGACTAATCTTCGAGGAAGTTCTGCCGCG
GCTGCTATGTTCTCCGCAGACCTCATGACTCCAAGAAGCTTTGCACATGATATGTTTAGG
ACGGCAGCTTATACTAACGGCGGTTCTGTGGCGGCGGCTTTGGATTATGGATATGGACAA
AGTGGTTATGGTAGTGTGAATTCAAACCCTAGTTCTCACCAAGTGTATCATCAAGGGGGT
GAGTATGAGCTCTTGAGGGAGATTTTTCCTTCAATTTTCTTTAAGCAAGAGCCTTGA
>AT5G45050.1 cds chromosome:TAIR10:5:18176914:18181973:-1 gene:AT5G45050 gene_biotype:protein_coding transcript_biotype:protein_coding gene_symbol:RRS1B description:Probable WRKY transcription factor 16 [Source:UniProtKB/Swiss-Prot;Acc:Q9FL92]
ATGACCGAGAGTGAGCAAATCGTCTACATCAGCTGCATAGAGGAGGTACGATACTCCTTC
GTCAGCCACCTCTCCAAAGCTCTCCAGCGAAAAGGTGTAAACGATGTCTTCATCGATAGC
GATGATTCGCTTTCCAACGAGTCTCAATCAATGGTCGAGAGAGCTAGGGTTTCTGTTATG
ATTTTACCAGGAAACCGTACGGTATCTCTTGACAAGCTCGTGAAGGTTCTCGATTGCCAG
AAGAACAAAGATCAAGTGGTGGTTCCGGTGTTGTACGGTGTCAGATCATCAGAGACCGAA
TGGCTTAGCGCGCTGGATTCGAAAGGATTCTCATCAGTACACCATTCCAGGAAAGAATGT
AGTGACTCCCAGCTTGTAAAAGAGACTGTTAGAGATGTGTATGAGAAGCTCTTTTATATG
GAACGAATTGGAATATATTCGAAGCTGCTGGAGATTGAGAAAATGATTAACAAGCAACCG
TTGGACATCCGTTGTGTTGGAATTTGGGGTATGCCTGGCATAGGCAAGACTACACTTGCT
AAAGCAGTCTTTGACCAAATGTCTGGTGAGTTTGATGCTCATTGCTTTATTGAAGACTAC
ACCAAAGCTATTCAAGAGAAGGGTGTTTATTGTTTGCTGGAGGAACAGTTTTTGAAAGAA
AATGCTGGTGCTAGTGGTACCGTTACGAAATTGAGCTTGCTTAGGGATAGATTAAACAAT
AAGAGGGTTCTTGTTGTTCTTGATGATGTCCGCAGTCCTCTGGTTGTGGAGTCTTTTCTT
GGAGGGTTTGACTGGTTTGGTCCCAAAAGTCTAATCATCATAACCTCCAAAGATAAATCG
GTGTTTCGCCTTTGTCGAGTCAATCAAATATACGAGGTTCAGGGTTTAAATGAGAAAGAG
GCTCTTCAACTCTTCTCTTTGTGTGCGTCTATAGACGATATGGCAGAGCAGAATCTCCAC
GAGGTGTCAATGAAAGTTATTAAATATGCTAATGGCCATCCATTAGCTCTCAATCTCTAT
GGCAGAGAACTGATGGGGAAGAAAAGACCACCAGAAATGGAGATAGCATTCCTCAAACTC
AAGGAATGTCCTCCAGCTATTTTTGTTGATGCAATCAAGAGCTCGTATGACACACTCAAT
GACAGGGAAAAAAACATTTTTTTGGACATAGCTTGTTTCTTCCAGGGAGAAAATGTTGAC
TACGTGATGCAACTGCTTGAGGGTTGTGGTTTCTTTCCACATGTTGGAATTGATGTTCTT
GTGGAGAAGAGTCTGGTGACTATTTCAGAAAACCGAGTGCGGATGCATAACTTGATCCAA
GATGTTGGCCGACAAATAATAAATAGAGAAACAAGACAGACTAAGAGGCGCAGCAGACTG
TGGGAACCTTGCAGCATCAAATATTTATTAGAAGATAAGGAACAAAACGAAAATGAAGAA
CAAAAAACAACTTTTGAACGTGCTCAGGTCCCTGAAGAGATCGAAGGCATGTTTCTGGAC
ACATCAAACTTAAGTTTTGATATTAAGCATGTTGCCTTTGATAATATGTTGAACCTTAGA
TTGTTCAAGATTTACAGTTCCAATCCTGAAGTCCATCATGTAAACAATTTCCTCAAAGGC
TCTCTCAGTTCTCTTCCTAATGTGCTAAGACTCCTGCATTGGGAGAACTATCCTCTGCAG
TTTCTGCCTCAAAATTTTGATCCTATACACCTTGTTGAAATCAACATGCCGTACAGCCAA
CTTAAGAAACTTTGGGGTGGAACCAAGGACCTGGAGATGTTGAAGACAATCAGGCTTTGT
CATTCCCAACAACTAGTTGATATTGACGATCTTTTAAAAGCTCAAAATCTTGAGGTAGTT
GATCTCCAAGGCTGTACAAGACTGCAGAGTTTCCCAGCCACCGGTCAATTGCTACATTTA
CGAGTTGTAAATCTCTCAGGTTGCACAGAGATCAAAAGTTTCCCAGAAATTCCCCCAAAT
ATTGAGACACTGAATCTACAGGGGACTGGTATAATAGAATTACCACTTTCCATTGTTAAG
CCAAACTACAGAGAGCTTTTGAATCTTCTAGCTGAAATCCCGGGTCTTTCAGGTGTCTCA
AACCTTGAGCAAAGTGATCTCAAACCTTTAACAAGCCTGATGAAAATTAGCACATCTTAC
CAAAATCCTGGCAAGCTTAGTTGCTTGGAGCTGAATGATTGTTCTCGTTTGCGAAGTCTG
CCAAACATGGTTAATTTAGAACTTCTCAAAGCCCTTGATCTTTCTGGTTGCTCAGAGCTC
GAGACTATCCAGGGTTTCCCACGGAACCTGAAAGAGTTATATCTTGTTGGCACTGCAGTA
AGACAAGTGCCACAACTTCCTCAAAGTCTAGAATTCTTTAATGCCCATGGTTGTGTCTCT
CTCAAATCAATTCGTTTGGACTTCAAGAAGCTTCCTGTGCATTACACATTTAGTAATTGT
TTCGATCTATCTCCACAAGTGGTCAACGATTTTTTAGTGCAGGCGATGGCTAATGTGATT
GCAAAACACATACCAAGAGAGCGTCATGTCACAGGCTTTTCTCAAAAGACTGTGCAGCGT
TCGAGTCGTGACAGTCAGCAGGAACTCAACAAAACTTTGGCTTTCAGCTTCTGTGCGCCC
TCACATGCGAATCAAAATTCCAAACTTGATCTGCAACCAGGATCTTCTTCAATGACACGA
CTAGATCCTTCTTGGAGGAACACACTTGTGGGCTTTGCTATGCTGGTGCAAGTCGCATTT
TCCGAGGGTTACTGTGATGATACTGATTTTGGCATTAGTTGTGTTTGCAAATGGAAAAAC
AAGGAAGGCCACTCTCATAGGAGAGAAATAAATTTGCATTGTTGGGCTTTAGGGAAAGCT
GTTGAAAGGGATCATACGTTTGTCTTCTTTGATGTCAACATGCGTCCAGATACCGATGAA
GGAAATGACCCCGATATCTGGGCTGATTTAGTTGTTTTTGAGTTCTTTCCTGTCAATAAA
CAGAGAAAGCCTCTAAATGATAGTTGCACAGTGACAAGATGTGGAGTCCGTTTAATAACT
GCTGTAAACTGCAATACAAGTATCGAGAATATATCACCAGTTTTGTCCTTGGATCCGATG
GAGGTTTCTGGTAATGAAGATGAAGAAGTATTGAGAGTCAGATATGCTGGTTTACAGGAG
ATATATAAAGCTTTGTTTCTTTACATAGCGGGTTTGTTCAATGACGAGGATGTTGGTTTG
GTAGCACCACTTATTGCTAACATTATTGACATGGACGTTAGTTATGGGCTCAAGGTCTTA
GCCTATAGGTCTCTCATACGTGTATCTTCCAATGGGGAAATAGTGATGCACTATTTGCTA
CGACAAATGGGTAAAGAAATCCTCCATACAGAATCAAAGAAGACTGACAAATTAGTCGAC
AATATTCAGAGTTCCATGATCGCAACAAAGGAAATCGAGATCACTCGTTCAAAGAGTCGC
CGAAAGAACAACAAGGAAAAGAGAGTGGTTTGCGTAGTGGATCGAGGCAGCCGGTCCAGT
GACCTATGGGTTTGGCGAAAGTATGGTCAAAAACCCATCAAAAGTTCTCCTTATCCAAGG
AGTTACTATAGATGTGCCAGCTCGAAAGGTTGTTTTGCTAGGAAACAAGTCGAACGTAGC
CGCACTGATCCAAATGTTTCAGTAATTACTTACATCTCTGAGCATAACCATCCATTCCCC
ACTCTACGCAATACTCTTGCCGGCTCCACTCGTTCCTCTTCCTCCAAATGCTCAGATGTA
ACTACTTCTGCCTCATCGACAGTCTCCCAAGACAAAGAAGGACCGGATAAATCCCATTTG
CCTTCCTCCCCTGCTTCTCCTCCTTATGCGGCCATGGTGGTTAAGGAGGAGGACATGGAG
CAATGGGACAATATGGAGTTCGATGTTGACGTTGAAGAAGATACTTTCATACCCGAATTA
TTTCCAGAGGATACCTTCGCTGATATGGACAAGCTTGAGGAAAATTCTCAGACTATGTTT
CTCTCTCGCAGAAGCAGCGGAGGCAACATGGAAGCCCAAGGGAAGAACTCTAGTGATGAT
AGGGAGGTCAATTTACCTAGTAAAATTCTGAATAGATAG

+ +

fastq文件 ：
详细介绍可以观看：https://www.omicsclass.com/course/28

+
@A00808:122:HM2JCDSXX:1:1101:3025:1000 1:N:0:TCGGAAGT+ACAAGGCT
AATTATTCCAAGTGATCATTTAATTTAACAGTACGTTATTACAGTTTTTGACAATACACCAGGAGGGGCAGAAGCAGCACTCCATTTATGCGCCGAATTCTCGTACAGACACACACACACACACAGATTCACACAGTCAATTCAGTCCTT
+
FFFFFFFFFFFF:FFFF:FFFFFFFFFFFFFFFFFFF,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:
@A00808:122:HM2JCDSXX:1:1101:4399:1000 1:N:0:TCGGAAGT+ACAAGGCT
CTTTGCTATAAACTAAGTCACCTTCTACAGCCTGCGAAATGCCATATTTTTCAACTCTGGCACTGGCAGCATGGTTCCAGAGGTAACTTTGGTAACTATGAACGTACATCATTCGTAATGTTCTTGGTATACTCTTTAATGCTTGCAGAT
+
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:F,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
@A00808:122:HM2JCDSXX:1:1101:8522:1000 1:N:0:TCGGAAGT+ACAAGGCA
NACTTTTCAGATTTCAACTTGAGAGATGGACCATCAAGAGCCTTTTTCATGTCACGTTTTTGAGCCATACAATGATACAGACGAAAGAAAACAAGCCAAACAACTCATCCAACCGACCGCGAACAGTAGACACAATTACACAAACACATG
+
#FFF,:FFF:,:FFF:F:FF:FFFFFF:FFF,F:FFF,F,:FF,:FFFF:FFFFF:FF,FF::,,FFFFFFFF:F:FFF,,,FFFFFF,FFF,:,:F::FFFFFFFFFFFFFF,FFFFFF:FFF,,F:,,F:F,:,FFF:,,FF:,FFFF
@A00808:122:HM2JCDSXX:1:1101:13205:1000 1:N:0:TCGGAAGT+ACAAGGCT
NTTCGACGAGGAGGCCGCCTGCGCGCGCGACGCCGCCGGGGAGGCCCTCGCGGCCTTCGAGTCGCTGCTCGCGCGCCTCCCCCCGCCCGACGCCGACTCGCGCCGCCGATCCATGGGGCTCAAGTTGGAGCAGCACAAAGCCGAGCTCAA
+
#FFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFF,F:FFFF,FFFFF,F,FFFFFF:FF:FF:FF:,:,,F,FFFFF,F,:F:FFF:,F,FFFFF,F,:,,,FFF::,:FFFF,FF:,:,:,,FFF,F,FF,,FFFFF,FFFF,FFFF
@A00808:122:HM2JCDSXX:1:1101:3902:1016 1:N:0:TCGGAAGT+ACAAGGCT
GTCGTCGTCACCGAATGTTGTCTTCTTTCCTGCACTAGGTGTACCAGCGCTCTGCTTGAACGGTGTACCCCGTCCACCACGGCCCCTGTCACCCCTACCAAAGCCTCTACCACGTCCACGGTCACCGCGCCCACGGCTACCATCACCACG
+
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFF
@A00808:122:HM2JCDSXX:1:1101:20518:1016 1:N:0:TCGGAAGT+ACAAGGCT
NGCTGGAGAACTAAGTGTCGATCTTCACCTTCACCAACAGATTCATGAACAAACCTAGCAGCGACACAAAAGCAAGACATTAGTAGTTGCAAATATTACTCTATCCAGTTAAGTTAGTATTTGAGAAGAGGGTAGGTGAAGCAGGTCGAA
+
#FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,FFFFFFFF:F,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
@A00808:122:HM2JCDSXX:1:1101:23158:1016 1:N:0:TCGGAAGT+ACAAGGCT
NTCCCTGGACTCTGGGGCACTTTAGGGCTAGGAACACTTGTCAAGCGACTCTGAGGCACAGTATCAGACATGGACTTCGAGAAGGCTTGTGCAAGCTCCAATGCAGATGCTCCTTTCCCAAAACGAGGTGCAACAACCTCAGGCTTTGGT
+
#FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFF
@A00808:122:HM2JCDSXX:1:1101:1597:1031 1:N:0:TCGGAAGT+ACAAGGCT
CGCCGCCGCACTCTGCAACCGCGCCGCGGGGAGGGAGGGAAGGACGAAGGAGGAAGGAGATGGAGCGGGTCGGCGGCGGGGAGAAGCAGCTGGAGGACTGCACCGTGTCCAATGCTCTCGGCACCTGGTTCTTCTCAGTTGCTGGTGCTC
+
F:FFFFFFFFFFFFFFFFFFFFFFFFFF,FF:FFF:FFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,FFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFF
@A00808:122:HM2JCDSXX:1:1101:3351:1031 1:N:0:TCGGAAGT+ACAAGGCT
CCCCCTTGAACTATCCGTAAATACCACCATTCCACCAAACTCCCCTCTGTCTTCTACGACAAATAATCTTTTCAACCCAGTAACTTATAATTAATTACAGAGAGATTAGCAAACATATAATGGTAAGAATCAGTTGTCGTAGGTGCGGCA
+
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFF:FF,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFF
@A00808:122:HM2JCDSXX:1:1101:5466:1031 1:N:0:TCGGAAGT+ACAAGGCT
CTCGCAGTGCTTGGTGTACTTGGCCGGGTCCAGCAGGGCGTCCAGCTCCGACGGGCTGCTCGGCTTCACCTTGATCATCCACCCGTCCTCGTACGGGCTTGAGTTAATCAGGCCGGGTGTCTCAGAGAGCTTGTCGTTAACCTCGACGAC
+
:FF:FF:F,FFFFF,FFFF:::FFF,F::F:F:,F,,,FFF:F::FFFF:FFF:F,:::FF:F,:FFFFFFFFFF,FFFFFFF::FFFF:FFFFFFFF:,FFFFFFFF,F,FF,F,FFF,:F,FFF,FFFF,FFFFF,F:,FFFFFFFFF
@A00808:122:HM2JCDSXX:1:1101:6714:1031 1:N:0:TCGGAAGT+ACAAGGCT
CGACGAGATCGGCCGCTCCGAATCCGATCCGCGCACGTGGTCTCGCCGGCGGGGTCAGGTTGGTTCGCGGGAGCCGCCGCCGCCGCCGACGACGACGACGATGGCCATGGAGACGCCGCCGCCGTTCCAGGAGTCCGCCCACTGCGACGT
+
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

+ +

==任务1 答案：==

+
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os

os.chdir("D:\\python_script")

idlist={}  #字典用于存储ID列表
f = open("idlist.txt", "r")  #打开ID列表文件
for line in f:
    line=line.strip()
    idlist[line]=1
f.close()

f_out = open("get.fa", "w")
for rec in SeqIO.parse("test.fa", "fasta"):
    if rec.id in idlist:  #判断ID是否存在与ID列表字典中
        SeqIO.write(rec,f_out,"fasta")   #如果存在写出该序列
        
f_out.close()
+

==任务2 答案：==

+
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os
import re
os.chdir("D:\\python_script")

idlist={}  #字典用于存储ID列表以及位置
f = open("id_pos.txt", "r")  #打开ID列表文件
for line in f:
    line=line.strip()
    tmp=re.split(r"\t",line)
    idlist[tmp[0]]=[int(tmp[1]),int(tmp[2])]
f.close()

f_out = open("get_pos.fa", "w")
for rec in SeqIO.parse("test.fa", "fasta"):
    if rec.id in idlist:  #判断ID是否存在与ID列表字典中
        start=idlist[rec.id][0]  #取得对应ID要截取的起始位置
        end=idlist[rec.id][1]   #取得对应ID要截取的结束位置
        rec_new=SeqRecord(rec.seq[start-1:end],id=rec.id,description=rec.description) #注意生物数据一般是从1作为索引，编程语言一般是从0开始所以要减一
        SeqIO.write(rec_new,f_out,"fasta")   #写出截取好的序列
        
f_out.close()
+ +

==任务3 答案：==

+
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os

os.chdir("D:\\python_script")
output_handle = open("fq2fa.fa", "w")
for rec in SeqIO.parse("test.fq", "fastq"):
    SeqIO.write(rec, output_handle, "fasta")

output_handle.close()
+ + +

==任务4 答案：==

+
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio import SeqIO
import os

os.chdir("D:\\python_script")
output_handle = open("trimed.fq", "w")
for rec in SeqIO.parse("test.fq", "fastq"):
    rec_new=rec[5:]
    SeqIO.write(rec_new, output_handle, "fastq")
output_handle.close()
+ +

6 Python 中数据统计分析包numpy 与 pandas

6.1 数据统计分析包介绍

    +

  • NumPy：N维数组矩阵容器； 基础的数学计算模块。

    +
    • +

  • Pandas：表格容器； 提供了一套名为DataFrame的数据结构，适合统计分析表格类数据。

    +
    • +

  • SciPy：科学计算函数库； 基于Numpy，提供方法(函数库)直接计算结果；封装了一些高阶抽象的物理模型。比方说做个傅立叶变换，做个滤波器等等。

    +
    • +
+

==非数学研究，建议直接入手Numpy，pandas。目的，是方便我们处理表格类的生物数据。==

+

6.2 Numpy包学习

Numpy：
用来存储和处理大型矩阵，本身是由C语言开发，和列表（list）的使用很像，但是计算速度要比列表快很多。

+ +

6.2.1 安装

# 使用 pip
pip install numpy -i  https://pypi.tuna.tsinghua.edu.cn/simple

#导入：
import numpy as np
+ +

6.2.2 矩阵/数组创建函数

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
函数描述
np.array()创建数组
np.zeros()创建数据全为0
np.ones()创建数据全为1
np.empty()创建数据接近0
np.arange()按指定范围创建数据
np.linspace()创建线段
+
import numpy as np #为了方便使用numpy 采用np简写
#列表转化为矩阵
a = np.array([2,23,4])
a = np.array([[11, 12, 13, 14, 15],
              [16, 17, 18, 19, 20],
              [21, 22, 23, 24, 25],
              [26, 27, 28 ,29, 30],
              [31, 32, 33, 34, 35]])
print(a)

#指定数据类型
a = np.array([2,23,4],dtype=np.int)
print(a.dtype)

a = np.arange(10,20,2) # 10-19 的数据，2步长
a = np.linspace(1,10,20)    # 开始端1，结束端10，且分割成20个数据，生成线段

a = np.zeros((3,4)) # 数据全为0，3行4列
a = np.ones((3,4),dtype = np.int)   # 数据为1，3行4列
a = np.empty((3,4)) # 数据为empty，3行4列
+ +
数据类型

NumPy支持的数值类型

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
符号含义
np.boolTrue和Flase
np.int支持int的32或64位
np.int88位的整形(-128~127)
np.int16-32768~32767
np.int32-2 ** 31 ~ 2 ** 31 - 1
np.int64-2 ** 63 ~ 2 ** 63 - 1
np.uint88位的整形(0~255)
np.uint16-32768~32767
np.uint320 ~ 2 ** 32 - 1
np.uint640 ~ 2 ** 64 - 1
np.float161位符号位，5位指数位，10位
np.float321位符号位，8位指数位，23位
np.float64、np.float1位符号位，11位指数位，52位
+

6.2.3 特定分布随机数创建矩阵函数

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
函数说明
np.random.rand(d0,d1,…,dn)根据d0-dn(维度)创建随机数数组，[0,1)，均匀分布
np.random.randn(d0,d1,…,dn)根据d0-dn(维度)创建随机数数组，标准正态分布
np.random.randint(low[,high,shape])根据shape创建随机整数或整数数组，范围是[low,high)
np.random.normal(loc,scale,size)产生具有正态分布的数组，loc为均值，scale标准差，size为形状
np.random.permutation(a)根据数组a的第1轴产生一个新的乱序数组，不改变数组a
np.random.choice(a[,size,replace,p])从一维数组a中以概率p抽取元素，形成size形状新数组replace表示是否可能重用元素，默认为False
np.random.uniform(low,high,size)产生具有均匀分布的数组，low起始值，high结束值，size为形状
np.random.poisson(lam,size)产生具有泊松分布的数组，lam为随机事件发生率，size为形状
+
import numpy as np #为了方便使用numpy 采用np简写

#产生均匀分布的数据，2x3x4 三维数据
np.random.rand(2,3,4) 

# 产生20个均值为2、标准差为0.1满足正态分布的随机数序列
a = np.random.normal(2, 0.1, 20)

+ + + +

6.2.4 矩阵/数组对象相关方法与属性

reshape() 和resize()方法
    +
  • reshape()方法，在reshape方法里以元组、列表给出变化后的形状数据，并不影响原数组会新生成一个多维数组。
    • +
  • resize() 方法，会修改数组本身的shape属性来改变数组的维度，原数组发生改变。
    • +
+
import numpy as np


#reshape方法，注意a被修改了
a = np.arange(12)
print(a)
a.reshape((3, 4))  
print(a)

#resize方法，注意a被修改了
a = np.arange(12)
a.resize([3, 4])
print(a)


#通过属性修改维度，注意a被修改了
a = np.arange(12)
print(a)
a.shape = (2, 6)


+ +
数组的一些属性
# Array properties
import numpy as np
a = np.array([[11, 12, 13, 14, 15],
              [16, 17, 18, 19, 20],
              [21, 22, 23, 24, 25],
              [26, 27, 28 ,29, 30],
              [31, 32, 33, 34, 35]])

print(type(a)) # >>><class 'numpy.ndarray'>    正如你在上面的代码中看到的，NumPy数组实际上被称为：多维数组，ndarray。
print(a.dtype) # >>>int32    数据类型
print(a.size) # >>>25    数据总个数
print(a.shape) # >>>(5, 5)   数组的形状是它有多少行和列，上面的数组有5行和5列，所以它的形状是(5，5)。
print(a.ndim) # >>>2   数组的维数。

+ + + +
矩阵数据支持索引，切片 类似列表
import numpy as np
a = np.arange(24)
print (a[3])

#二维数组索引
#对于2D数组：行的切片，列的切片。
a = np.arange(12)
a = a.reshape((3, 4))
print(a[0, 1:4])
print(a[1:4, 0])
print(a[::2,::2])

#三维数组索引
a = np.arange(24)
b = a.reshape((2, 3, 4))
print (b[1,1:2,1:])

+ +
数组支持布尔筛选
import numpy as np
a = np.arange(0, 100, 10)
b = a[:5]
c = a[a >= 50]
print(b) 
print(c) 


# Where 函数筛选
a = np.arange(0, 100, 10)
b = np.where(a < 50) 
c = np.where(a >= 50)[0]
print(b) 
print(c)
+ + + +

6.2.5 NumPy的数学统计函数

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
函数说明
np.abs() np.fabs()计算数组各元素的绝对值
np.sqrt()计算数组各元素的平方根
np.square()计算数组各元素的平方
np.log(x),np.log10(x),np.log2(x)计算数组各元素的自然对数、10底对数和2底对数
np.ceil(x),np.floor(x)计算数组各元素的ceiling值或floor值
np.rint(x)计算数组各元素的四舍五入值
np.modf(x)将数据各元素的整数和小数部分以两个独立的数组形式返回
np.cos/cosh/sin/sinh/tan/tanh计算数据各元素的普通型和双典型的三角函数
np.exp(x)计算数组各元素的指数值
np.sum(a,axis=None)根据给定axis计算数组a相关元素之和，axis整数或元组
np.mean(a,axis=None)根据给定axis计算数组a相关元素的期望，axis整数或元组
np.average(a,axis=None,weights=None)根据给定axis计算数组a相关元素的加权平均值
np.std(a,axis=None)根据给定轴axis计算数组a相关元素的标准差
np.var(a,axis = None)根据给定轴axis计算数组a相关元素的方差
np.cov(a,axis = None)计算协方差
np.corrcoef计算相关系数，参阅
np.min(a) max(a)计算数组a中元素的最小值，最大值
np.argmin(a) argmax(a)计算数组a中元素的最小值，最大值的降一维后下标
np.unravel_index(index,shape)根据shape将一维下标index转换成多维下标
np.ptp(a)计算数组a中元素最大值和最小值的差
np.median(a)计算数组a中元素的中位数(中值)
+

iris.data测试数据下载：https://archive.ics.uci.edu/ml/machine-learning-databases/iris/

+
import numpy as np
import os
os.chdir("D://python_script//")
a, b = np.loadtxt("iris.data",  delimiter=',', usecols = [0, 1],unpack=True)
print(a)
print(b)

print(np.average(a))
print(np.mean(a))
print(np.max(a))
print(np.argmax(a))
print(np.min(a))
print(np.argmin(a), a[np.argmin(a)])
print(np.ptp(a))
print(np.std(a))
print(np.median(a))
print(np.sqrt(a), np.square(a))
print(np.rint(a))
print(np.ceil(a))


#print(np.column_stack([a, b]))
+

NumPy的算术运算，类似线性代数计算

+
import numpy as np
# Basic Operators
a = np.arange(25)
a = a.reshape((5, 5))

b = np.array([10, 62, 1, 14, 2, 56, 79, 2, 1, 45,
              4, 92, 5, 55, 63, 43, 35, 6, 53, 24,
              56, 3, 56, 44, 78])
b = b.reshape((5,5))

print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a ** 2)
print(a < b) 
print(a > b)
+ + +

6.3 Pandas简介

基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。最具有统计意味的工具包，某些方面优于R软件。数据结构有一维的Series，二维的DataFrame，三维的Panel。

+ +

Pandas数据类型

    +
  • Series：一维数组，与Numpy中的一维array类似。二者与Python基本的数据结构List也很相近，其区别是：List中的元素可以是不同的数据类型，而Array和Series中则只允许存储相同的数据类型，这样可以更有效的使用内存，提高运算效率。
    • +
  • DataFrame：二维的表格型数据结构。很多功能与R中的data.frame类似。可以将DataFrame理解为Series的容器。
    • +
  • Time-Series：以时间为索引的Series。
    • +
  • Panel：三维的数组，可以理解为DataFrame的容器。则可以视为excel的多表单sheet。
    • +
+

6.3.1 安装

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple/  pandas

import pandas as pd
+ +

6.3.2 创建Series

Series构造函数的name参数是给这列数据指定字段名。从结果可以看出t有两个名为’a’的label，值分别为2和7。

+
import pandas as pd
i = ["a", "c", "d", "a"]
v = [2, 4, 5, 7]
t = pd.Series(v, index=i, name = "col_name")
print(t)

#数据的访问，支持索引，切片，name取值
print("t[d]->", t["d"])
print('t[0 : 3]->', t[0 : 3])
print('t["a" : "c"]->', t["c" : "d"])  #注意label唯一才行，不然会报错

+ +

image

+

Series对象的方法与属性

get方法

首先看看get方法，可以返回指定的key所对应的value值

+
import pandas as pd
idx =  "hello the cruel world".split()
val = [1, 21, 13, 104]
t = pd.Series(val, index = idx)

t.get("the")
t.get("The", "None")  #如果key不存在，返回default的值。

+ +
add、append方法

add和append方法都能改变series，只不过add类似于加法操作，而append则是连接。

+
import pandas as pd
idx =  "hello the cruel world".split()
val1 = [1, 21, 13, 104]

t = pd.Series(val1, index = idx)

val2 = [4, 4, 4, 4]
s = pd.Series(val2, index = idx)
t.add(s) 
t + 4

t.append(s)

+ +

6.3.3 DataFrame创建

Pandas的Dataframe是二维的，每一列都是一个Series结构。

+
#手动创建
import pandas as pd
import numpy as np
df1 = pd.DataFrame({'A': 1.,
                    'B': pd.date_range('20130101', periods=4),
                    'C': pd.Series(1, index=list(range(4)), dtype='float32'),
                    'D': np.array([3] * 4, dtype='int32'),
                    'E': ["test", "train", "test", "train"],
                    'F': 'foo'},index=list("abcd"))
#numpy矩阵手动创建
df2 = pd.DataFrame(np.random.randn(10,3), columns = ["ca", "cb", "cc"], index =list("abcdefghij"))

+ + + +

DataFrame对象的属性与方法学习

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
属性描述
columnscolumns属性可以获得dataframe有那些列，即dataframe的index
shapeshape属性是描述dataframe的形状的
sizedataframe的size属性返回的是dataframe的value的个数
values返回当前dataframe的数据和index、columns相对应。
dtypes述当前dataframe的里的每列值的数据类型。
ndim返回数据框维度
Tdataframe的T属性，实际是转置的意思。
+
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10,3), columns = ["ca", "cb", "cc"], index =list("abcdefghij"))
df.columns
df.index
df.shape
df.size
df.values
df.dtypes
df.ndim
df.T

#方法
df.head()
df.tail(3)
df.to_numpy()
df.describe()  #方法显示数据的快速统计摘要
+ + +

DataFrame数据访问与筛选

需要特别注意的是DataFrame和其他表格数据不一样的是，DataFrame是列访问机制。

+
import pandas as pd
import numpy as np
val = np.arange(10, 40).reshape(10, 3)
idx = ["ax", "bx", "cx"]
df = pd.DataFrame(val, columns = idx,index=list("abcdefghij"))

#[]号访问列
df["ax"]   #单列索引
df[["ax", "cx"]]  #多列手动选择

#利用列名访问列
df.ax

#DataFrame[start:end]则是通过切片选择的是行。
df["a" : "e"]
df[:3]    #多列切片


###利用方法进行选择

#按位置索引选择：iloc[]行列切片
df.iloc[1] #单独使用选择行
df.iloc[2 : 6, 0 : 2]   #行列选择
df.iloc[[0, 1, 3]]   #不同行选择
df.iloc[[0, 1, 3],[2,1]]   #不同行列选择


#按标签选择  loc[]行列切片， 行列的名字  dataFrame里可以通过loc[]的方式选择label标识的行数据。
df.loc["a"] #单独使用选择行
df.loc[["a","c"]]
df.loc[["a","c"],["ax","cx"]]
df.loc["b" : "e", "bx" : "cx"]
df.loc[: , "bx" : "cx"]


+ +
bool逻辑筛选数据
import pandas as pd
import numpy as np
val = np.arange(10, 60).reshape(10, 5)
col = ["ax", "bx", "cx", "dx", "ex"]
idx = list("abcdefghij")
df = pd.DataFrame(val, columns = col, index = idx)

#筛选，bx列大于30的数据
bs = df["bx"] > 30
df[bs]

#组合选择，bx列大于30的数据并且cx列大于40的数据

bs = (df["bx"] > 30) & (df["cx"] > 40)
df[bs]     #选择符合条件的行

#布尔选择的结果还是DataFrame，所以对于结果可以进行切片、label、loc等访问。

+ + +
dataframe数据分类统计（重要）

apply 方法 和 groupby方法对数据进行分类统计

+
import pandas as pd
import numpy as np
val = np.arange(10, 60).reshape(10, 5)
col = ["ax", "bx", "cx", "dx", "ex"]
idx = list("abcdefghij")
df = pd.DataFrame(val, columns = col, index = idx)

df.apply(lambda col : col.sum(), axis = 0)  #求列的和
df.apply(lambda row : row.sum(), axis = 1)  #求行的和
df["plus"] = df.apply(lambda row : row.ax + row.cx, axis = 1) #两列相加，并增加新列，plus
df
+

groupby 方法，实现分类汇总

+
import pandas as pd
idx = [101,101,101,102,102,102,103,103,103]
name = ["apple","pearl","orange", "apple","pearl","orange","apple","pearl","orange"]
price = [1.0,2.0,3.0,4.00,5.0,6.0,7.0,8.0,9.0]
df0 = pd.DataFrame({ "fruit": name, "price" : price, "supplier" :idx})

dg =  df0.groupby("fruit")

#批量查看分组结果
for n, g in dg:
    print("group_name:", n, "\n",g,)

#分析结果总结
dg.describe()

#选择需要研究的列,属性或者方法获得统计结果
dg['price'].mean() 
dg['supplier'].value_counts()


#多个分组，大分组之后再分亚组
import pandas as pd
idx = [101,101,101,102,102,102,103,103,103,101,101,101,102,102,102,103,103,103]
name = ["apple","pearl","orange", "apple","pearl","orange","apple","pearl","orange","apple","pearl","orange", "apple","pearl","orange","apple","pearl","orange"]
price = np.arange(18)
df0 = pd.DataFrame({ "fruit": name, "price" : price, "supplier" :idx})

dg2 =  df0.groupby(["fruit", "supplier"])
for n, g in dg2:
    print("multiGroup on:", n, "\n",g)
dg2.describe()

+ +

==groupby方法总结==

+
+

首先通过groupby得到DataFrameGroupBy对象, 然后选择需要研究的列,这样我们就得到了一个SeriesGroupby, 它代表每一个组都有一个Series
对SeriesGroupby进行操作, 比如.mean(), 相当于对每个组的Series求均值

+
+

6.3.4 pandas 应用：读入写出数据处理数据

测试数据：https://archive.ics.uci.edu/ml/machine-learning-databases/iris/

+
import os
import pandas as pd
os.chdir("D://python_script//")
fn = "D://python_script//iris.data"
cols_name = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'class']
df = pd.read_csv(fn, names = cols_name)  #更多读取数据：https://pandas.pydata.org/pandas-docs/stable/reference/io.html

data_df=df.iloc[:,0:4]   #筛选一下数据

#利用apply计算：行列的和

data_df.apply(lambda col : col.sum(), axis = 0)
data_df.apply(lambda row : row.sum(), axis = 1)

#自定义计算
data_df["sepal_length x sepal_width"] =data_df.apply(lambda row : row.sepal_width * row.sepal_length, axis = 1)
data_df

data_df.to_csv("out.csv")  #计算结果写出

+ + + +]]> + + Learn_Python + + + Python + + + + Python 绘图matplotlib包科学绘图 + /2024/07/02/Python%E7%BB%98%E5%9B%BEmatplotlib/ + Python 绘图matplotlib包科学绘图

Matplotlib:

+

Python中最著名的绘图系统，pandas绘图也是由其封装而成。

+

官方网站：https://matplotlib.org/

+

1 认识matplotlib绘图包绘图要素以及对应的类（对象）

+

The whole figure. The figure keeps track of all the child Axes, a smattering of ‘special’ artists (titles, figure legends, etc), and the canvas。

+

The top level container Artist is the matplotlib.figure.Figure

+ +

This is what you think of as ‘a plot’, it is the region of the image with the data space. A given figure can contain many Axes, but a given Axes object can only be in one Figure.

+ +

These are the number-line-like objects. They take care of setting the graph limits and generating the ticks (the marks on the axis) and ticklabels (strings labeling the ticks).

+ +

Basically everything you can see on the figure is an artist (even the Figure, Axes, and Axis objects). This includes Text objects, Line2D objects, collection objects, Patch objects … (you get the idea).

+

要素之间的关系：

image

+

多张图，要素之间的关系：

image

+

Figure中更详细对象总结

image

+

2 matplotlib包安装

安装说明：
https://matplotlib.org/users/installing.html#installing-an-official-release

+
pip install matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple

#jupyter 支持绘图显示，命令行需要安装运行以下代码：

pip install ipympl  -i https://pypi.tuna.tsinghua.edu.cn/simple
jupyter nbextension enable --py --sys-prefix ipympl
+ + + +

3 matplotlib绘图基础

matplotlib.pyplot 绘图入口模块

==matplotlib.pyplot 模块中有很多函数，我们直接调用就可以绘图：==

+

Everything in matplotlib is organized in a hierarchy. At the top of the hierarchy is the matplotlib “state-machine environment” which is provided by the matplotlib.pyplot module.

+

我们使用matplotlib.pyplot 里面的函数来创建绘图，绘图主要有以下三步：

+ +

示例代码：

+
#########################################
#载入包，模块等等
#########################################
import matplotlib.pyplot as plt
import numpy as np

###########################
##第一步和第二步：  获得，Figure对象和Axes对象
###########################

#方法1：
fig = plt.figure(figsize=(8, 6))
ax1 = fig.add_axes([0.1, 0.1, 0.35, 0.8])
ax2 = fig.add_axes([0.55, 0.1, 0.35, 0.8])

#或者
ax1 = fig.add_subplot(211)
ax2 = fig.add_subplot(212)


#方法2：
fig, ax = plt.subplots(figsize=(8, 6))
#或者 
fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2,figsize=(8, 6))

##########################
##第三步： 绘图
#############################

x = np.linspace(0, 2, 100)   
fig, ax = plt.subplots(figsize=(8, 6))



ax.plot(x, x, label='linear')
ax.plot(x, x**2, label='quadratic')
ax.plot(x, x**3, label='cubic')
ax.set_xlabel('x label')
ax.set_ylabel('y label')
ax.set_title("Simple Plot")
ax.legend()

plt.show()

#保存图片
#plt.savefig("D:\\python_script\\test.pdf")
#plt.savefig("D:\\python_script\\test.png",dpi=300)
+ + +

面向对象绘图和面向过程的绘图

推荐面向对象的绘图，思路会更加清晰。

+
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2, 100)
plt.plot(x, x, label='linear')
plt.plot(x, x**2, label='quadratic')
plt.plot(x, x**3, label='cubic')
plt.xlabel('x label')
plt.ylabel('y label')
plt.title("Simple Plot")
plt.legend()
plt.show()

+

3 学会自学绘图

方法模板的API：每个类、方法、函数，参数的详细说明

https://matplotlib.org/api/index.html#modules

+

使用说明

https://matplotlib.org/users/index.html

+

利用例子学习绘图

https://matplotlib.org/gallery/index.html

+]]> + + Learn_Python + + + Python + + diff --git a/tags/Python/index.html b/tags/Python/index.html new file mode 100644 index 0000000..904da68 --- /dev/null +++ b/tags/Python/index.html @@ -0,0 +1,403 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 标签: Python | Bio_Learning + + + + + + + + + + + + +
+
+ +
+
+
+
+ + + +
+
+ +
+ + + +

Bio_Learning

+ + +

yang51的学习笔记

+
+ +
+
+
+
+
+ + + + + + + + + +
+
+ + +
+ + 0% +
+ + +
+
+
+ + +
+ + + + + +
+
+
+

Python + 标签 +

+
+ + +
+ 2024 +
+ + + + + + + +
+
+ + + + + + + + +
+ + + + +
+ + +
+ + + +
+ + + + + +
+
+ + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/tags/\350\275\257\344\273\266/index.html" "b/tags/\350\275\257\344\273\266/index.html" index 0c18de2..47bad36 100644 --- "a/tags/\350\275\257\344\273\266/index.html" +++ "b/tags/\350\275\257\344\273\266/index.html" @@ -260,12 +260,16 @@

软件
- 3 + 6 日志
-
+
1 + 分类 +
+
+ 2 标签