python匿名函数表达式中调用方法_python基础-匿名函数、内置函数、正则表达式、模块...

1. 匿名函数

1.1 有名函数

有名函数：定义了一个函数名，函数名指向内存地址；通过函数名进行访问。函数名加括号就可以运行有名函数，例如：func()

def func(x, y, z = 1):return x + y +zprint(func(1,5,2))

1.2 匿名函数

匿名函数：没有名字的函数，定义的时候不需要函数名；定义匿名函数的关键字是：lambda

特点：

1.没有函数名

2.函数自带return

应用场景：

1.应用于一次性的地方

2.临时使用

salaries={'egon':3000,'alex':100000000,'wupeiqi':10000,'yuanhao':2000}#打印工资最高的人名，利用匿名函数很好的解决此问题

print(max(salaries,key=lambda name:salaries[name]))

2. 内置函数

官方内置函数网址：https://docs.python.org/3/library/functions.html

2.1 概览

2.2 abs all any

1.abs        求绝对值

2.all 可迭代对象取出所有值，进行判断，所有为真就返回True

如果可迭代对象为空，返回True 例如：all([])

3.any

可迭代对象取出所有值，进行判断，任何一个为真就返回True

如果可迭代对象为空，返回False 例如：any([])

print(abs(-100))print(all([1,-20,None])) #只要有一个为假，返回False

print(all([1,-20,"a"])) #只要所有为真，返回True

print(all([])) #可迭代对象为空，返回True

print(any([1,-20,None])) #只要有一个为真，返回True

print(any([])) #可迭代对象为空，返回False

print(any(['',None,False])) #所有为假，返回False

2.3 bool

bool值为假的情况

1.None

2.空

3.False

4.0

2.4 bin oct hex

1.bin 十进制转换为二进制

2.oct 十进制转换为八进制

3.hex十进制转化为十六进制

print(bin(10)) #0b1010

print(oct(10)) #0o12

print(hex(10)) #0xa

2.5 bytes

print('hello'.encode('utf-8')) #unicode----encode----->bytes

print(bytes('hello',encoding='utf-8')) #利用bytes把unicode转化为bytes

2.6 callable

callable：判断一个对象是否可调用，是否可用加括号运行的，例如：函数

print(callable(bytes))print(callable(abs))

2.7 chr ord

chr：用一个十进制数字，利用chr函数，转换为一个ascii表中的一个字符

ord：字符转化为数字

A—Z  65到90

print(chr(65)) #A

print(chr(90)) #Z

print(ord('H')) #72

2.8 数据类型

内置函数，又被称为工厂函数

目前了解的数据类型如下：

1.int                 整形

2.complex         复数

3.float                浮点

4.str                  字符串

5.list                  列表

6.tuple               元组

7.dict                 字典

8.set                 可变集合

9.frozenset     不可变集合

x=1 #x=int(1)

print(type(x)) #

x=int(2)

s={1,2,3,4} #s=set({1,2,3,4})

print(type(s)) #

s1=frozenset({1,2,3,4})print(type(s1)) #

2.9 dir

利用dir，可以查看一个模块可以调用的属性和方法

importsys

sys.path#path是sys的属性

print(dir(sys)) #查看sys点可以调用的属性和方法

2.10 divmod

利用divmod，获得被除数除以除数，得到商和余数

print(divmod(10,3)) #(3, 1)

print(divmod(102,20)) #(5, 2)

2.11 enumerate

enumerate，把一个可迭代对象，生成一个迭代器

l=['a','b','c']

res=enumerate(l)for i inres:print(i)for index,item inenumerate(l):print(index,item)

2.12 hash

hash，校验一个字符串值，只要字符串的值一样，hash结果就一样

print(hash('abcdefg123')) #hash 结果为：-203804489563080217

print(hash('abcdefg123')) #hash 结果为：-203804489563080217

print(hash('abcdefg123')) #hash 结果为：-203804489563080217

2.13 help

利用help，查看函数的文档信息；给函数加文档解释，用到单引号，双引号，三引号

deffunc():'''test function

:return:'''

pass

print(help(func))

2.14 id

id:是python解释器实现的功能，只是反映了变量在内存的地址，但并不是真实的内存地址

x=1

print(id(x))def func():pass

print(id(func))print(func) #最精准的内存地址反映

2.15 isinstance

isinstance，判断一个变量是否属于一个数据类型

x=1

print(type(x) isint)print(isinstance(x,int))

2.16 max min

max：求最大值，同类型之间进行比较

min：求最小值，同类型之间进行比较

print(max([1,2,3,10]))print(max(['a','b']))print(min([1,2,3,10]))

2.17 pow

pow求幂运算

print(pow(3,5))print(pow(3,2,2)) #3**2%2

2.18 repr str

repr、str都是把数字转化为字符串

repr：给解释器用的

str： 给用户用的

print(type(str(100))) #输出结果：

print(type(repr(100))) #输出结果：

2.19 reversed

reversed：反转，也就是倒排序

l=[1,'a',2,'c']print(list(reversed(l))) #['c', 2, 'a', 1] 反转产生新列表，并不反转原列表

print(l) #[1, 'a', 2, 'c']

2.20 round

利用round，保留小数位数，并进行四舍五入

示例

print(round(2.764,2)) #运行结果：2.76

print(round(2.768,2)) #运行结果：2.77

2.21 slice

slice，是切片的意思，调用slice函数，生产切片对象，方便进行重用，为很多列表所用。

l=[1,2,3,4,5,6]print(l[0:4:2])

s=slice(0,4,2)print(l[s])

2.22 sorted

排序，同类型之间进行排序

l=[1,10,4,3,-1]print(sorted(l)) #排序，从小到大排序，运行结果：[-1, 1, 3, 4, 10]

print(sorted(l,reverse=True)) #从大到小排序，运行结果：[10, 4, 3, 1, -1]

2.23 sum

利用sum求和

print(sum([1, 2,3]))print(sum(i for i in range(10)))

2.24 zip

zip拉链，把两个序列类型生成一个小元组列表

s='hello'l=[1,2,3,4,5]print(list(zip(s,l))) #运行结果：[('h', 1), ('e', 2), ('l', 3), ('l', 4), ('o', 5)]

2.25 __import__

__import__，导入模块，把字符串转化为模块类型

m_name=input('module>>:')if m_name == 'sys':

m=__import__(m_name)print(m)print(m.path)

sys=__import__('sys')print(sys)

2.26 内置函数补充

薪资字典

salaries={'egon':3000,'alex':100000000,'wupeiqi':10000,'yuanhao':2000}

2.26.1 max

获取薪资最大的人名

print(max(salaries,key=lambdaname:salaries[name]))print(min(salaries,key=lambda name:salaries[name]))

内置函数max、min的实质是通过循环，比较最大值和最小值，只是默认比较key，可以通过函数的第二个参数key选择比较value值

通过max内部实现机制：通过for循环，只获取一个值，传给匿名函数lambda name:salaries[name])，把执行结果作为比较依据，然后进行比较，比较的依据是max的第二个参数的运行结果

salaries={'egon':3000,'alex':100000000,'wupeiqi':10000,'yuanhao':2000}#利用zip实现需求，十分复杂#知识储备

t1=(10000000,'alex')

t2=(3000,'egon')print(t1 > t2) #运行结果：True

print(max(salaries)) #最大的name值，运行结果：yuanhao

print(max(salaries.values())) #最大的values值，运行结果：100000000#取出name和value，利用zip转为元组，最后进行比较

print(max(zip(salaries.values(),salaries.keys()))[1])defget_value(name):returnsalaries[name]print(max(salaries,key=get_value))print(max(salaries,key=lambda name:salaries[name])) #薪资最大的人名：alex

print(min(salaries,key=lambda name:salaries[name])) #薪资最小的人名：yuanhao

2.26.2 sorted

比较薪资从小到大的人名

salaries ={"egon":3000,"alex":100000000,"wupeiqi":100000,"yuanhao":2000,

}defget_value(name):returnsalaries[name]print(sorted(salaries,key=get_value)) #运行结果： ['yuanhao', 'egon', 'wupeiqi', 'alex']

print(sorted(salaries,key=lambda name:salaries[name],reverse=True)) #运行结果：['alex', 'wupeiqi', 'egon', 'yuanhao']

2.26.3 map

filter、map、reduce，都是对一个集合进行处理；filter很容易理解用于过滤，map用于映射，reduce用于归并. 是Python列表方法的三架马车。

map函数：func作用于给定序列的每个元素，并用一个列表来提供返回值

names=['alex','wupeiqi','yuanhao','yanglei','egon']

res=map(lambda x:x if x == 'egon' else x+'SB',names)print(res) #运行结果：

print(list(res)) #运行结果：['alexSB', 'wupeiqiSB', 'yuanhaoSB', 'yangleiSB', 'egon']

N1=[1,2,3]

N2=[6,5,4]print(list(map(lambda x,y:x+y,N1,N2))) #运行结果：[7, 7, 7]

print(list(map(lambda x:x+3,N1))) #运行结果：[4, 5, 6]

2.26.4 reduce

reduce函数：func为二元函数，将func作用于seq序列的元素，每次携带一对(先前的结果以及下一个序列的元素)，连续的将现有的结果和下一个值作用在获得的随后的结果上，最后减少我们的序列为一个单一的返回值

from functools importreduceprint(reduce(lambda x,y:x+y,range(101),100)) #运行结果：5150

print(reduce(lambda x,y:x+y,range(101))) #运行结果：5050

#用map和reduce实现5的阶乘相加(5!+4!+3!+2!+1!)

print(reduce(lambda x,y:x*y,range(1,6)))print(reduce(lambda x,y:x*y,range(1,5)))print(reduce(lambda x,y:x*y,range(1,4)))print(reduce(lambda x,y:x*y,range(1,3)))print(reduce(lambda x,y:x*y,range(1,2)))#把上一步的结果变成一个阶乘列表

print(list(map(lambda a:reduce(lambda x,y:x*y,range(1,a+1)),range(1,6)))) #运行结果：[1, 2, 6, 24, 120]#最后把阶乘列表相加

print(reduce(lambda m,n:m+n,map(lambda a:reduce(lambda x,y:x*y,range(1,a+1)),range(1,6)))) #运行结果：153

2.26.5 filter

filter函数的功能相当于过滤器。调用一个布尔函数bool_func来迭代遍历每个seq中的元素；返回一个使bool_seq返回值为true的元素的序列。

names=['alex_SB','wupeiqi_SB','yuanhao_SB','yanglei_SB','egon']print(list(filter(lambda name:name.endswith('SB'),names))) #运行结果：['alex_SB', 'wupeiqi_SB', 'yuanhao_SB', 'yanglei_SB']

N=range(10)print(list(filter(lambda x:x>5,N))) #运行结果：[6, 7, 8, 9]

3. 正则表达式

3.1 概览

模式

描述

\w

匹配字母数字下划线

\W

匹配非字母数字下划线

\s

匹配任意空白字符，等价于[\t\n\r\f]

\S

匹配任意非空字符

\d

匹配任意数字，等价于[0-9]

\D

匹配任意非数字

\A

匹配字符串开始

\Z

匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串

\z

匹配字符串结束

\G

匹配最后匹配完成的位置

\n

匹配一个换行符

\t

匹配一个制表符

^

匹配字符串开头

$

匹配字符串的结尾

.

匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。

[…]

用来表示一组字符，单独列出：[amk]匹配’a’,’m’或者’k’

[^…]

不在[]中的字符：[^abc]匹配除了a,b,c之外的字符

*

匹配0个或多个的表达式

+

匹配1个或多个的表达式

?

匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式

{n}

精准匹配n个前面表达式

{n,m}

匹配n到m次，由前面的曾泽表达式定义的片段，贪婪方式

a|b

匹配a或则b

()

匹配括号内的表达式，也表示一个组

3.2 基本正则

importreprint(re.findall('\w','hello_ | egon 123')) #运行结果：['h', 'e', 'l', 'l', 'o', '_', 'e', 'g', 'o', 'n', '1', '2', '3']

print(re.findall('\W','hello_ | egon 123')) #运行结果：[' ', '|', ' ', ' ']

print(re.findall('\s','hello_ | egon 123 \n \t')) #运行结果：[' ', ' ', ' ', ' ', '\n', ' ', '\t']

print(re.findall('\S','hello_ | egon 123 \n \t')) #运行结果：['h', 'e', 'l', 'l', 'o', '_', '|', 'e', 'g', 'o', 'n', '1', '2', '3']

print(re.findall('\d','hello_ | egon 123 \n \t')) #运行结果：['1', '2', '3']

print(re.findall('\D','hello_ | egon 123 \n \t')) #运行结果：['h', 'e', 'l', 'l', 'o', '_', ' ', '|', ' ', 'e', 'g', 'o', 'n', ' ', ' ', '\n', ' ', '\t']

print(re.findall('h','hello_ | hello h egon 123 \n \t')) #运行结果：['h', 'h', 'h']

print(re.findall('\Ahe','hello_ | hello h egon 123 \n \t')) #运行结果：['he']

print(re.findall('^he','hello_ | hello h egon 123 \n \t')) #运行结果：['he']

print(re.findall('123\Z','hello_ | hello h egon 123 \n \t123')) #运行结果：['123']

print(re.findall('123$','hello_ | hello h egon 123 \n \t123')) #运行结果：['123']

print(re.findall('\n','hello_ | hello h egon 123 \n \t123')) #运行结果：['\n']

print(re.findall('\t','hello_ | hello h egon 123 \n \t123')) #运行结果：['\t']

3.3 . [] [^]

.本身代表任意一个字符

[]内部可以有多个字符，但是本身只配多个字符中的一个

[^…]不在[]中的字符：[^abc]匹配除了a,b,c之外的字符

importre#.本身代表任意一个字符

print(re.findall('a.c','a a1c a*c a2c abc a c aaaaaac')) #运行结果：['a1c', 'a*c', 'a2c', 'abc', 'a c', 'aac']

print(re.findall('a.c','a a1c a*c a2c abc a\nc',re.DOTALL)) #运行结果：['a1c', 'a*c', 'a2c', 'abc', 'a\nc']

print(re.findall('a.c','a a1c a*c a2c abc a\nc',re.S)) #运行结果：['a1c', 'a*c', 'a2c', 'abc', 'a\nc']

#[]内部可以有多个字符，但是本身只配多个字符中的一个

print(re.findall('a[0-9][0-9]c','a a12c a1c a*c a2c a c a\nc',re.S)) #运行结果： ['a12c']

print(re.findall('a[a-zA-Z]c','aac abc aAc a*c a2c a c a\nc',re.S)) #运行结果：['aac', 'abc', 'aAc']#[^…]不在[]中的字符：[^abc]匹配除了a,b,c之外的字符

print(re.findall('a[^a-zA-Z]c','aac abc aAc a*c a2c a c a\nc',re.S)) #运行结果：['a*c', 'a2c', 'a c', 'a\nc']

print(re.findall('a[\+\/\*\-]c','a-c a+c a/c a1c a*c a2c a\nc',re.S)) #运行结果：['a-c', 'a+c', 'a/c', 'a*c']

3.4 \:转义

原生字符串r rawstring；正则表达式前面加r，表示原生的

importre#\:转义 r代表rawstring

print(re.findall(r'a\\c','a\c abc')) #运行结果['a\\c']

3.5 ? * + {}

? * + {}：左边有几个字符，如果有的话，贪婪匹配

?左边那一个字符有0个或者1个

*左边那一个字符有0个或者无穷个

+左边那一个字符有1个或者无穷个

{n,m}左边的字符有n-m次

importre#? * + {}：左边有几个字符，如果有的话，贪婪匹配#?左边那一个字符有0个或者1个

print(re.findall('ab?','aab a ab')) #运行结果： ['a', 'ab', 'a', 'ab']

#*左边那一个字符有0个或者无穷个

print(re.findall('ab*','a ab abb abbb abbbb')) #运行结果：['a', 'ab', 'abb', 'abbb', 'abbbb']

print(re.findall('ab{0,}','a ab abb abbb abbbb')) #运行结果：['a', 'ab', 'abb', 'abbb', 'abbbb']

#+左边那一个字符有1个或者无穷个

print(re.findall('ab+','a ab abb abbb abbbb')) #运行结果：['ab', 'abb', 'abbb', 'abbbb']

print(re.findall('ab{1,}','a ab abb abbb abbbb')) #运行结果：['ab', 'abb', 'abbb', 'abbbb']

#{n,m}左边的字符有n-m次

print(re.findall('ab{3}','a ab abb abbb abbbb')) #运行结果：['abbb', 'abbb']

print(re.findall('ab{2,3}','a ab abb abbb abbbb')) #运行结果：['abb', 'abbb', 'abbb']

3.6 .* .*?

importre#.* .*?#.*贪婪匹配，匹配所有字符

print(re.findall('a.*c','a123c456c')) #运行结果：['a123c456c']#.*?非贪婪匹配，获取最短的

print(re.findall('a.*?c','a123c456c')) #运行结果：['a123c']

3.7 |

| 表示或者，左侧条件成立，不会匹配右侧条件；左侧条件不成立，才匹配右侧条件

print(re.findall('company|companies','Too many companies have gone bankrupt, and the next one is my company')) #运行结果：['companies', 'company']

3.8 ():分组

importre#(ab)，匹配成功，显示组内内容ab#(?:ab) 匹配成功，显示匹配最完全的内容

print(re.findall('ab+','abababab123')) #运行结果：['ab', 'ab', 'ab', 'ab']

print(re.findall('ab+123','abababab123')) #运行结果：['ab123']

print(re.findall('ab','abababab123')) #运行结果：['ab', 'ab', 'ab', 'ab']

print(re.findall('(ab)','abababab123')) #运行结果：['ab', 'ab', 'ab', 'ab']

print(re.findall('(a)b','abababab123')) #运行结果：['a', 'a', 'a', 'a']

print(re.findall('a(b)','abababab123')) #运行结果：['b', 'b', 'b', 'b']

print(re.findall('(ab)+','abababab123')) #运行结果：['ab']

print(re.findall('(?:ab)+','abababab123')) #运行结果：['abababab']

print(re.findall('(ab)+123','abababab123')) #运行结果：['ab']

print(re.findall('(?:ab)+123','abababab123')) #运行结果：['abababab123']

print(re.findall('(ab)+(123)','abababab123')) #运行结果：[('ab', '123')]

print(re.findall('compan(y|ies)','Too many companies have gone bankrupt, and the next one is my company')) #运行结果：['ies', 'y']

print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company')) #运行结果：['companies', 'company']

4. 模块

4.1 re模块

4.1.1 findall

匹配成功，接着匹配，查找匹配成功的所有内容

print(re.findall('ab','abababab123')) #运行结果：['ab', 'ab', 'ab', 'ab']

4.1.2 search

匹配成功一次，直接返回；只找到匹配成功一次结果。利用group查看内容

print(re.search('ab','ababab123').group()) #运行结果：ab

print(re.search('ab','12aasddds')) #运行结果：None

print(re.search('ab','12aasab3ss').group()) #运行结果：ab

4.1.3 match

从开头开始查找，可以用search代替

print(re.search('ab','123ab456'))print(re.match('ab','123ab456')) #等价于print(re.search('^ab','123ab456'))

4.1.4 split

切分

print(re.split('b','abcde')) #运行结果：['a', 'cde']#利用a切分之后，再用b进行切分

print(re.split('[ab]','abcde')) #运行结果：['', '', 'cde']

4.1.5 sub

sub：替换

print(re.sub('alex','SB','alex make love alex alex')) #运行结果：SB make love SB SB#指定替换次数

print(re.sub('alex','SB','alex make love alex alex',2)) #运行结果：SB make love SB alex

print(re.subn('alex','SB','alex make love alex alex',2)) #运行结果：('SB make love SB alex', 2)

print(re.sub('(\w+)( .* )(\w+)',r'\3\2\1','alex make love'))#运行结果：love make alex

4.2 time模块

三种形式的时间：时间戳、结构化时间、格式化的字符串时间

各种时间之间的转换关系

importtimeprint(time.time()) #时间戳， 运行结果：1502011120.8090527

print(time.strftime('%Y-%m-%d %X')) #格式化字符串时间 运行结果：2017-08-06 17:18:40

print(time.localtime()) #格式化时间运行结果：time.struct_time(tm_year=2017, tm_mon=8, tm_mday=6, tm_hour=17, tm_min=18, tm_sec=40, tm_wday=6, tm_yday=218, tm_isdst=0)

print(time.gmtime()) #UTC 运行结果：time.struct_time(tm_year=2017, tm_mon=8, tm_mday=6, tm_hour=9, tm_min=18, tm_sec=40, tm_wday=6, tm_yday=218, tm_isdst=0)

print(time.localtime().tm_mon) #运行结果：8

print(time.localtime(123123123)) #运行结果：time.struct_time(tm_year=1973, tm_mon=11, tm_mday=26, tm_hour=8, tm_min=52, tm_sec=3, tm_wday=0, tm_yday=330, tm_isdst=0)

print(time.gmtime(123123123)) #运行结果：time.struct_time(tm_year=1973, tm_mon=11, tm_mday=26, tm_hour=0, tm_min=52, tm_sec=3, tm_wday=0, tm_yday=330, tm_isdst=0)

print(time.mktime(time.localtime())) #运行结果：1502011120.0

print(time.strftime('%Y',time.gmtime())) #运行结果：2017

print(time.strptime('2017-03-01','%Y-%m-%d')) #运行结果：time.struct_time(tm_year=2017, tm_mon=3, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=60, tm_isdst=-1)

print(time.ctime(12312312)) #运行结果：Sat May 23 20:05:12 1970

print(time.asctime(time.gmtime())) #运行结果：Sun Aug 6 09:18:40 2017

4.3 random

importrandomprint(random.random()) #(0,1)----float 大于0且小于1之间的小数

print(random.randint(1, 3)) #[1,3] 大于等于1且小于等于3之间的整数

print(random.randrange(1, 3)) #[1,3) 大于等于1且小于3之间的整数

print(random.choice([1, '23', [4, 5]])) #1或者23或者[4,5]

print(random.sample([1, '23', [4, 5]], 2)) #列表元素任意2个组合

print(random.uniform(1, 3)) #大于1小于3的小数，如1.927109612082716

item = [1, 3, 5, 7, 9]

random.shuffle(item)#打乱item的顺序,相当于"洗牌"

print(item)

生成随机验证码

importrandomdefmake_code(n):

res= ""

for i inrange(n):

s1= str(random.randint(0,9))

s2= chr(random.randint(65,90))

res+=random.choice([s1,s2])returnresprint(make_code(10)) #运行结果：92324635B3

4.4 os模块

os模块是与操作系统交互的一个接口

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径

os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd

os.curdir 返回当前目录: ('.')

os.pardir 获取当前目录的父目录字符串名：('..')

os.makedirs('dirname1/dirname2') 可生成多层递归目录

os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname

os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

os.remove() 删除一个文件

os.rename("oldname","newname") 重命名文件/目录

os.stat('path/filename') 获取文件/目录信息

os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为:

os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'os.system("bash command") 运行shell命令，直接显示

os.environ 获取系统环境变量

os.path.abspath(path) 返回path规范化的绝对路径

os.path.split(path) 将path分割成目录和文件名二元组返回

os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素

os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False

os.path.isabs(path) 如果path是绝对路径，返回True

os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False

os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False

os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间

os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间

os.path.getsize(path) 返回path的大小

View Code

示例：

importosprint(os.listdir('.'))print(os.stat('m1.py').st_size)print(os.sep)print(os.linesep)print(os.pathsep)print([os.sep,os.linesep,os.pathsep])

res=os.system('dir .') #运行结果：返回命令执行结果

print(os.path.dirname(r'C:\a\b\c\d\a.txt')) #运行结果：C:\a\b\c\d

print(os.path.basename(r'C:\a\b\c\d\a.txt'))#运行结果：a.txt

print(os.path.split(r'C:\a\b\c\d\a.txt')) #运行结果：('C:\\a\\b\\c\\d', 'a.txt')

print(os.stat('m1.py').st_atime) #运行结果：1502012851.6810527

print(os.stat('m1.py').st_size) #运行结果：49

print(os.path.getsize('m1.py')) #运行结果：49

print(os.path.join('C:\\','a','b','c','d.txt')) #运行结果：C:\a\b\c\d.txt

print(os.path.join('C:\\','a','b','D:\\','c','d.txt')) #运行结果：D:\c\d.txt

print(os.path.normcase('c:/wiNdows\\system32\\')) #运行结果：c:\windows\system32\

print(os.path.normpath('c://wIndows\\System32\\../Temp/')) #运行结果：c:\wIndows\Temp

a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..'

print(os.path.normpath(a)) #运行结果：\Users\jieli\test1

print(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) #运行结果：D:\python\code\Learning

BASE_DIR=os.path.normpath(os.path.join(

os.path.abspath(__file__),'..','..')

)print(BASE_DIR) #运行结果：D:\python\code\Learning

4.5 Sys模块

4.5.1 介绍

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          返回操作系统平台名称

4.5.2 sys.stdout实现进度条

importsys,timefor i in range(1,100):

sys.stdout.write('\r%s' %('#'*i))

sys.stdout.flush()

time.sleep(0.5)

4.5.3 print实现进度条实现

importsys,timefor i in range(1,100):print('\r%s' %('#'*i),file=sys.stdout,flush=True,end='')

time.sleep(0.05)

4.5.4进度条应用

知识储备

#通过传入参数，指定滚动条的固定宽度

print('' %'hello')print('' %'hello')print('' %'#')print('' %'##')print('' %'###')print('' %'####')print('' %'#####')

width=20

print('' %width) #

print(('' %width) %('hello')) # %('hello')

print(('[%%-%ds]' %width) %('#'))print(('[%%-%ds]' %width) %('##'))print(('[%%-%ds]' %width) %('###'))

实现打印进度条函数

importsys,timedef progress(percent,width=50):if percent >= 100:

percent=100show_str=('[%%-%ds]' %width) %(int(width*percent/100)*'#')print('\r%s %d%%' %(show_str,percent),file=sys.stdout,flush=True,end='')

total_size=80251recv_size=0while recv_size

time.sleep(0.3) #模拟下载的网络延迟

recv_size+=1024recv_per=int(100*recv_size/total_size)

progress(recv_per,width=50)

4.6 序列化

为什么要序列化？

1.持久保存状态

2.跨平台数据交互

4.6.1 json

JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

importjson

dic={'name':'egon','age':18}#利用dumps序列化

print(type(json.dumps(dic)))

with open('a.json','w') as f:

f.write(json.dumps(dic))#利用loads反序列化

with open('a.json','r') as f:

data=f.read()

dic=json.loads(data)print(dic['name'])

dic={'name':'egon','age':18}#利用dump序列化

json.dump(dic,open('b.json','w'))#利用load反序列化

print(json.load(open('b.json','r'))['name'])

4.6.2 pickle

Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

importpickle

dic={'name':'egon','age':18}#dumps序列化

print(pickle.dumps(dic))

with open('d.pkl','wb') as f:

f.write(pickle.dumps(dic))#loads反序列化

with open('d.pkl','rb') as f:

dic=pickle.loads(f.read())print(dic['name'])

dic={'name':'egon','age':18}#dump序列化

pickle.dump(dic,open('e.pkl','wb'))#load反序列化

print(pickle.load(open('e.pkl','rb'))['name'])

利用pickle进行序列化python的函数，然后进行反序列化

importpickledeffunc():print('反序列化的文件')#利用dump把函数进行序列化

pickle.dump(func,open('func.pkl','wb'))#利用load把函数进行反序列化

f=pickle.load(open('func.pkl','rb'))print(f)

f()

4.7 shelve模块

shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型

4.7.1 序列化

importshelve#进行序列化

f=shelve.open(r'sheve.shl')

f['alex']={'age':28,'pwd':'alex3714'}

f['egon']={'age':18,'pwd':'3714'}

f.close()

4.7.2 反序列化

importshelve

obj=shelve.open(r'sheve.shl')print(obj['alex'])print(obj['egon'])for i inobj:print(i,obj[i])

obj.close()