python基础-匿名函数、内置函数、正则表达式、模块

1. 匿名函数

1.1 有名函数

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

def func(x, y, z = 1):
    return x + y + z
print(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)) # <class ‘int‘>
x=int(2)

s={1,2,3,4}      #s=set({1,2,3,4})
print(type(s))   # <class ‘set‘>

s1=frozenset({1,2,3,4})
print(type(s1))  # <class ‘frozenset‘>

2.9 dir

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

import sys
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 in res:
    print(i)
for index,item in enumerate(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，查看函数的文档信息；给函数加文档解释，用到单引号，双引号，三引号

def func():
    ‘‘‘
    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) is int)
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)))   # 输出结果： <class ‘str‘>
print(type(repr(100)))  # 输出结果： <class ‘str‘>

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=lambda name: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])

def get_value(name):
    return salaries[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,
}
def get_value(name):
    return salaries[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)     # 运行结果：<map object at 0x0000000002219B70>
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 import reduce
print(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 基本正则

import re
print(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之外的字符

import re
#.本身代表任意一个字符
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，表示原生的

import re
#\:转义 r代表rawstring
print(re.findall(r‘a\\c‘,‘a\c abc‘)) # 运行结果[‘a\\c‘]

3.5 ? * + {}

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

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

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

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

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

import re
#? * + {}：左边有几个字符，如果有的话，贪婪匹配
#?左边那一个字符有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 .* .*?

import re
# .* .*?
#.*贪婪匹配，匹配所有字符
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 ():分组

import re
# (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模块

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

　　各种时间之间的转换关系

import time

print(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

import random

print(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)

　　生成随机验证码

import random

def make_code(n):
    res = ""
    for i in range(n):
        s1 = str(random.randint(0,9))
        s2 = chr(random.randint(65,90))
        res += random.choice([s1,s2])
    return res

print(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的大小

　　示例：

import os

print(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实现进度条

import sys,time

for i in range(1,100):
    sys.stdout.write(‘\r%s‘ %(‘#‘*i))
    sys.stdout.flush()
    time.sleep(0.5)

4.5.3 print实现进度条实现

import sys,time
for i in range(1,100):
    print(‘\r%s‘ %(‘#‘*i),file=sys.stdout,flush=True,end=‘‘)
    time.sleep(0.05)

4.5.4进度条应用

　　知识储备

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

print(‘<%s>‘ %‘hello‘)
print(‘<%-10s>‘ %‘hello‘)

print(‘<%-10s>‘ %‘#‘)
print(‘<%-10s>‘ %‘##‘)
print(‘<%-10s>‘ %‘###‘)
print(‘<%-10s>‘ %‘####‘)
print(‘<%-10s>‘ %‘#####‘)

width=20
print(‘<%%-%ds>‘ %width) #<%-10s>
print((‘<%%-%ds>‘ %width) %(‘hello‘))  # <%-10s> %(‘hello‘)

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

　　实现打印进度条函数

import sys,time
def progress(percent,width=50):
    if percent >= 100:
        percent=100
    show_str=(‘[%%-%ds]‘ %width) %(int(width*percent/100)*‘#‘)
    print(‘\r%s %d%%‘ %(show_str,percent),file=sys.stdout,flush=True,end=‘‘)

total_size=80251
recv_size=0

while recv_size < total_size:
    time.sleep(0.3) #模拟下载的网络延迟
    recv_size+=1024
    recv_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内置的数据类型对应如下：

import json
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保存那些不重要的数据，不能成功地反序列化也没关系。

import pickle

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的函数，然后进行反序列化

import pickle

def func():
    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 序列化

import shelve

# 进行序列化
f=shelve.open(r‘sheve.shl‘)
f[‘alex‘]={‘age‘:28,‘pwd‘:‘alex3714‘}
f[‘egon‘]={‘age‘:18,‘pwd‘:‘3714‘}
f.close()

4.7.2 反序列化

import shelve

obj=shelve.open(r‘sheve.shl‘)

print(obj[‘alex‘])
print(obj[‘egon‘])

for i in obj:
    print(i,obj[i])
obj.close()

时间： 2024-10-21 10:10:25