Python学习心得——基础知识

Posted 2020-07-25

一、冒泡排序

 1、要求

把列表中无序的字符按小到大排序：[9,6,15,11,36,28]

2、思路

把列表中相邻的字符值进行排序，值的放到右侧，逐个比较直到满足要求，类似水中的气泡朝水面移动。

3、样例

针对列表[9，236，1，7，5，18]按从小到大排序

 1 #!usr/bin/env python
 2 # -*- coding: utf-8
 3 
 4 lis=[9,236,1,7,5,18]
 5 for i in range(1,len(lis)):        #判断有几次大循环数据比较
 6     for j in range(len(lis)-i):    #取列表值的索引
 7         if lis[j]>lis[j+1]:
 8             temp=lis[j]
 9             lis[j]=lis[j+1]
10             lis[j+1]=temp
11 print(lis)

 

二、递归

 1、思路

一个函数内部调用自身函数，那这个函数就是递归函数

2、知名样例

斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368...

当某个元素的值大于10000时，结束调用，展示满足条件的斐波那契数列

 1 #!usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 
 4 def f1(a1,a2):
 5     if a1>10000:    #若元素大于10000,结束调用
 6         return
 7     print(a1)
 8     a3=a1+a2
 9     f1(a2,a3)
10 r=f1(0,1)

 

三、装饰器

1、定义

装饰器是函数，它用来装饰其它函数或类，也就是对其它函数或类进行包装；作用是可以不在改变其它函数或类的功能下，添加相应功能。

2、样例

若f1函数的功能是打印‘功能1’，现在要不改变f1函数的前提下，调用f1函数，先打印‘功能2’，然后打印‘功能1’，最后打印‘功能3’

 1 #!usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 
 4 def f2(arge):
 5     def inner():
 6         print(‘功能2‘)
 7         arge()
 8         print(‘功能3‘)
 9     return inner
10 
11 @f2         #装饰器特有的标示
12 def f1():
13     print(‘功能1‘)
14 
15 f1()

内部逻辑是怎么样的呢，请看下面图形分解

第1步：

第2步：

第3步：

第4步：

第5步：

第6步：

第7步：

第8步：

第9步：

第10步：

第11步：

第12步：

 3、被装饰的函数有一个参数

 1 #!usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 
 4 def f2(func):
 5     def inner(arge):
 6         print(‘功能2‘)
 7         func(arge)
 8         print(‘功能3‘)
 9     return inner
10 
11 @f2         #装饰器特有的标示
12 def f1(arge):
13     print(‘功能1‘)
14 
15 arge=‘abc‘
16 f1(arge)

4、动态参数

 1 #!usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 
 4 def f2(func):
 5     def inner(*arge,**kwargs):
 6         print(‘功能2‘)
 7         func(*arge,**kwargs)
 8         print(‘功能3‘)
 9     return inner
10 
11 @f2         #装饰器特有的标示
12 def f1(arge1,arge2,arge3):
13     print(‘功能1‘)
14 
15 arge1=‘abc‘
16 arge2=‘uio‘
17 arge3=‘haoyun‘
18 f1(arge1,arge2,arge3)

5、多个装饰器

 1 #!usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 
 4 def f3(func):
 5     def inner(*arge,**kwargs):
 6         print(‘功能5‘)
 7         func(*arge,**kwargs)
 8         print(‘功能4‘)
 9     return inner
10 
11 
12 def f2(func):
13     def inner(*arge,**kwargs):
14         print(‘功能2‘)
15         func(*arge,**kwargs)
16         print(‘功能3‘)
17     return inner
18 @f3
19 @f2         #装饰器特有的标示
20 def f1(arge1,arge2,arge3):
21     print(‘功能1‘)
22 
23 arge1=‘abc‘
24 arge2=‘uio‘
25 arge3=‘haoyun‘
26 f1(arge1,arge2,arge3)

 

 四、正则

说明:正则本着会用即可的原则，此处直接引用了老师的佳作

1、语法

1 2 3 4 5 6

import re #导入模块名   p = re.compile("^[0-9]")  #生成要匹配的正则对象 ， ^代表从开头匹配，[0-9]代表匹配0至9的任意一个数字， 所以这里的意思是对传进来的字符串进行匹配，如果这个字符串的开头第一个字符是数字，就代表匹配上了   m = p.match(‘14534Abc‘)   #按上面生成的正则对象 去匹配 字符串， 如果能匹配成功，这个m就会有值， 否则m为None<br><br>if m: #不为空代表匹配上了 　　print(m.group())　　　　#m.group()返回匹配上的结果，此处为1，因为匹配上的是1这个字符<br>else:<br>　　print("doesn‘t match.")<br>

上面的第2 和第3行也可以合并成一行来写：

m = p.match("^[0-9]",‘14534Abc‘)

效果是一样的，区别在于，第一种方式是提前对要匹配的格式进行了编译（对匹配公式进行解析），这样再去匹配的时候就不用在编译匹配的格式，第2种简写是每次匹配的时候 都 要进行一次匹配公式的编译，所以，如果你需要从一个5w行的文件中匹配出所有以数字开头的行，建议先把正则公式进行编译再匹配，这样速度会快点。

 2、匹配格式

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

 3、正则表达式五种常用操作

re.match(pattern, string)　　　　 # 从头匹配

re.search(pattern, string)　　　　# 匹配整个字符串，直到找到一个匹配

re.split()　　　　　　　　　　　　# 将匹配到的格式当做分割点对字符串分割成列表

1 2	>>>m = re.split("[0-9]", "alex1rain2jack3helen rachel8") >>>print(m)

输出：　[‘alex‘, ‘rain‘, ‘jack‘, ‘helen rachel‘, ‘‘]

re.findall()　　　　　　　　　　# 找到所有要匹配的字符并返回列表格式

1 2	>>>m = re.findall("[0-9]", "alex1rain2jack3helen rachel8") >>>print(m)<br>

输出：[‘1‘, ‘2‘, ‘3‘, ‘8‘]

re.sub(pattern, repl, string, count,flag) 　　　# 替换匹配到的字符

1 2	m=re.sub("[0-9]","|", "alex1rain2jack3helen rachel8",count=2 ) print(m)

输出：alex|rain|jack3helen rachel8

 

五、模块

1、概念

模块它是多个功能的集合。

 

2、模块的分类

A：内置模块——python自带的模块

B：自定义模块——自己写的模块

C：第三方模块

 

3、模块导入格式

import  ‘模块名‘  

如：import re

 

4、常用的内置模块介绍

time/datetime模块

 1 #_*_coding:utf-8_*_
 2 import time
 3 import datetime
 4  
 5 print(time.clock()) #返回处理器时间,3.3开始已废弃
 6 print(time.process_time()) #返回处理器时间,3.3开始已废弃
 7 print(time.time()) #返回当前系统时间戳
 8 print(time.ctime()) #输出Tue Jan 26 18:23:48 2016 ,当前系统时间
 9 print(time.ctime(time.time()-86640)) #将时间戳转为字符串格式
10 print(time.gmtime(time.time()-86640)) #将时间戳转换成struct_time格式
11 print(time.localtime(time.time()-86640)) #将时间戳转换成struct_time格式,但返回 的本地时间
12 print(time.mktime(time.localtime())) #与time.localtime()功能相反,将struct_time格式转回成时间戳格式
13 #time.sleep(4) #sleep
14 print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将struct_time格式转成指定的字符串格式
15 print(time.strptime("2016-01-28","%Y-%m-%d") ) #将字符串格式转换成struct_time格式
16  
17 #datetime module
18  
19 print(datetime.date.today()) #输出格式 2016-01-26
20 print(datetime.date.fromtimestamp(time.time()-864400) ) #2016-01-16 将时间戳转成日期格式
21 current_time = datetime.datetime.now() #
22 print(current_time) #输出2016-01-26 19:04:30.335935
23 print(current_time.timetuple()) #返回struct_time格式
24  
25 #datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])
26 print(current_time.replace(2014,9,12)) #输出2014-09-12 19:06:24.074900,返回当前时间,但指定的值将被替换
27  
28 str_to_date = datetime.datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M") #将字符串转换成日期格式
29 new_date = datetime.datetime.now() + datetime.timedelta(days=10) #比现在加10天
30 new_date = datetime.datetime.now() + datetime.timedelta(days=-10) #比现在减10天
31 new_date = datetime.datetime.now() + datetime.timedelta(hours=-10) #比现在减10小时
32 new_date = datetime.datetime.now() + datetime.timedelta(seconds=120) #比现在+120s
33 print(new_date)

 

sys模块——用于提供对解释器相关的操作

1 sys.argv           命令行参数List，第一个元素是程序本身路径
2 sys.exit(n)        退出程序，正常退出时exit(0)
3 sys.version        获取Python解释程序的版本信息
4 sys.maxint         最大的Int值
5 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
6 sys.platform       返回操作系统平台名称
7 sys.stdout.write(‘please:‘)
8 val = sys.stdin.readline()[:-1]

 

os模块——用于提供系统级别的操作

 1 os.getcwd()                #获取当前工作目录，即当前python脚本工作的目录路径
 2 os.chdir("dirname")        #改变当前脚本工作目录；相当于shell下cd
 3 os.curdir                  #返回当前目录: (‘.‘)
 4 os.pardir                  #获取当前目录的父目录字符串名：(‘..‘)
 5 os.makedirs(‘dirname1/dirname2‘)    #可生成多层递归目录
 6 os.removedirs(‘dirname1‘)           #若目录为空，则删除，并递归到上一级目录，如若也为空，
 7                                      则删除，依此类推
 8 os.mkdir(‘dirname‘)        #生成单级目录；相当于shell中mkdir dirname
 9 os.rmdir(‘dirname‘)        #删除单级空目录，若目录不为空则无法删除，报错；相当于shell
10                             中rmdir dirname
11 os.listdir(‘dirname‘)      #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
12 os.remove()                #删除一个文件
13 os.rename("oldname","newname")      #重命名文件/目录
14 os.stat(‘path/filename‘)            #获取文件/目录信息
15 os.sep                     #输出操作系统特定的路径分隔符，win下为"\\\\",Linux下为"/"
16 os.linesep                 #输出当前平台使用的行终止符，win下为"\\t\\n",Linux下为"\\n"
17 os.pathsep                 #输出用于分割文件路径的字符串
18 os.name                    #输出字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘
19 os.system("bash command")           #运行shell命令，直接显示
20 os.environ                          #获取系统环境变量
21 os.path.abspath(path)               #返回path规范化的绝对路径
22 os.path.split(path)                 #将path分割成目录和文件名二元组返回
23 os.path.dirname(path)      #返回path的目录。其实就是os.path.split(path)的第一个元素
24 os.path.basename(path)     #返回path最后的文件名。如何path以／或\\结尾，那么就会返回空值。
25                             即os.path.split(path)的第二个元素
26 os.path.exists(path)       #如果path存在，返回True；如果path不存在，返回False
27 os.path.isabs(path)        #如果path是绝对路径，返回True
28 os.path.isfile(path)       #如果path是一个存在的文件，返回True。否则返回False
29 os.path.isdir(path)        #如果path是一个存在的目录，则返回True。否则返回False
30 os.path.join(path1[, path2[, ...]]) #将多个路径组合后返回，第一个绝对路径之前的参数
31                                      将被忽略
32 os.path.getatime(path)     #返回path所指向的文件或者目录的最后存取时间
33 os.path.getmtime(path)     #返回path所指向的文件或者目录的最后修改时间