python&&函数&&学习笔记

python&&函数&&学习笔记

Eclipse的使用

1.包（package）与文件夹（folder）区别

若文件夹中包含"__init__.py"文件，那么该文件夹可以被称为包，否则只能被称作文件夹

2.设置断点

在代码行编号前面使用鼠标双击即可设置断点

3.debug测试

在eclipse软件的功能行中点击虫子按钮即可开启debug模式

模块和模块的常用方法

__init__.py :
    文件夹内包含"__init__.py"才被称作包。包含"__init__.py"的不同目录下的不同文件可以直接访问其文件模块。
    
__name__：

#!/usr/bin/env python
#coding:utf-8
#"from 模块 import 文件名"，导入模块。
from File import  demo
#判断"__name__"是否等于"__main__",若等于，则当前文件是主文件，否则，这输出"模块.文件名"
if __name__ == '__main__':
    print ("this is a main")    

通过__name__判断当前文件是不是__main__，可以有效的防止别人恶意引用、盗用你的python程序。

__file__:
    指当前文件所在路径
__doc__:
    指模块级别下的注释内容

#!/usr/bin/env python
#coding:utf-8
'''
date:2019-08-12
author:dfq
'''
print(__file__)
print(__doc__)
#D:\backupAll\eclipseRoot\project001\main\index.py
#date:2019-08-12
#author:dfq

函数式编程

- 参数                 def  Fun(arg,*args,**kargs):
- 默认参数          print  arg
- 可变参数          print args
- 返回值             return 'success'

简单函数定义、调用示例：

#!/usr/bin/env python
#coding:utf-8
def foo(name):
    print(name,'买彩票中奖')
foo('路人甲')
foo('路人乙')

简单登陆功能（函数调用让代码更简洁）实例：

#!/usr/bin/env python
#coding:utf-8
from ctypes.test.test_pickling import name
from pip._vendor.distlib.compat import raw_input

def login(username):
    if username == 'alex':
        print('是她，是她，就是她')
        return '登陆成功'
    else:
        print('来错地了，老弟~')
        return '登录失败'

def detail(user):
    print(user,'我们的英雄，小哪吒')
    
if __name__ == '__main__':
    user = raw_input('请输入用户名')
    result = login(user)
    if result == '登陆成功':
        detail(user)
    else:
        print('all over')

函数的默认参数示例：

#!/usr/bin/env python
#coding:utf-8

def foo(name,time = '今天',action = '0.1元'):
    print(name,time,'中奖',action)

foo('路人甲','上辈子','1000000元')
foo('路人乙', action = '100元')
foo('路人丙')

有默认值的默认参数(action)需要放在无默认值的参数(name)后面，否则会报错
当传输的参数中包含不使用默认值的参数时，需通过’参数 = 值’ 的方式指定参数赋值

函数接收任意多参数示例：

#!/usr/bin/env python
#coding:utf-8
#接收客户列表打印炫酷名单
'''
def show(arg):
    for item in arg:
        #各种炫酷效果
        print(item)

show(['jia','yi','bing'])
#使用列表方式传参数到函数
'''
def shows(*arg):
    for item in arg:
        print(item)

shows('jia','yi','bing')
#在参数（arg）前面加'*',代表该函数可以接收传入的任意多的参数的值

函数接收任意多字典结构类型的参数实例：

#!/usr/bin/env python
#coding:utf-8
#函数接收人任意多字典结构的参数，并按照字典规则('key' = 'value')处理接受的值
def show(**kargs):
    print(kargs)
    for item in kargs.items():
        print(item)
#直接传入字典结构类型的参数
show(name = '路人乙',sex = 'girl')
#通过字典变量间接传入字典结构类型的参数，需在字典变量前面加两个'*'
dict_example = {'name' : '路人甲','sex' : 'boy'}
show(**dict_example)

yield介绍:

#!/usr/bin/env python
#coding:utf-8
from pip._vendor.msgpack.fallback import xrange
#首先，介绍一下'range'与'xrange'的区别。
#'range'会立刻创建10个数，即立刻创建
print(range(10))
#'xrange'会在被遍历时创建10个数，即延迟创建
print(xrange(10))
for item in xrange(10):
    print(item)

#如何实现延迟创建功能，这里就需要用到'yield','yield'是一个生成器，
def foo():
    yield 1
    yield 2
    yield 3
    yield 4
    yield 5
    
re = foo()
#若函数内定义了'yield',当直接调用该函数时,则返回生成器，而非生成器生成的数值
print(re)
#当对生成器进行遍历操作时，才可返回生成器生成的数值，且每次遍历仅执行一条'yield'语句
#每次遍历操作均从上次结束的位置开始执行，即遍历过程中会保留执行到哪条'yield'w位置记录，每条'yield'在整个遍历过程中仅执行一次
for item in re:
    print(item)

使用yield实现xreadlines功能：

#!/usr/bin/env python
#coding:utf-8

def alexReadLines():
    seek = 0
    while True:
        '''
        'with'功能 等同于'file' + 'read' + 'close'
        f = file('/usr/local/readlineTest.txt','r')
        f.read()
        f.close()
        '''
        #打开文件
        with open('/usr/local/readlineTest.txt', 'r') as f:
            #跳到指定字节位置，开始读文件
            f.seek(seek)
            #读一行
            data = f.readline()
            #是否读到数据
            if data:
                #获取当前读到的字节位置并存在'seek'中，下次从'seek'位置继续读文件
                seek = f.tell()
                #读取的数据放在'yield'中
                yield data
            #读不到数据时，退出读取循环
            else:
                return 
#遍历生成器，打印生成器'yield'对应的值
for item in alexReadLines():
    print(item)                

yield作用1：当你遇到写多线程代码时，可以使用’yield’创建一个线程池，每当有线程需要时便从线程池中取出。
yield作用2：可以保存函数执行过程中的执行状态。通过对函数执行状态的保存，可以让函数在系统空闲（或对函数结果有需要）时运行，在系统繁忙（或暂不需要立刻拿到函数的输出结果）时暂停执行，可以有效的防止系统阻塞（系统不必呆呆的等着一个函数的执行结果，可以在需要结果的时候继续执行函数）。

建议：正常工作过程中，一个功能部分的代码建议不超过一个屏幕的范围

三元运算

代码示例：

#!/usr/bin/env python
#coding:utf-8

result = 'get' if 1 > 3 else 'post'
print(result)

简化冗杂的判断代码

Lambda表达式

代码示例：

#!/usr/bin/env python
#coding:utf-8

a = lambda x,y:x + y
print(a(4,10))

单行生成列表示例：

>>>[x*2 for x in range(10)]
[0,2,4,6,8,10,12,14,16,18]
#遍历0到9，并将输出结果乘2

map示例：

>>>map(lambda x:x*2,range(10))
[0,2,4,6,8,10,12,14,16,18]
#遍历0~9，并使用lambda方法令结果乘以2输出。

内置函数

• help()
  帮助
• dir()
• vars()
• type()
• import temp
• reload(temp)
• id()

内置函数使用示例：

#!/usr/bin/env python
#coding:utf-8
from builtins import type
from File import demo
from imp import reload
from _functools import reduce
#使用help帮助了解变量、方法等的使用
a = []
#'a = []' 等同于 'a = list()' ,本质上是通过调用一个类生成列表，即创建了一个类的实例
help(a)
#以字符串的形式列出当前全部内置函数
print(dir())
#以键值对的形式列出当前全部内置函数
print(vars())
#列出目标的类型
print(type(a))
#<class 'list'>
#默认模块不会重复导入，使用'reload()'方法可以重复导入模块
reload(demo)
#使用'id()'方法可以确认某两个变量是否是同一个id.
dfq = 1994
print(id(dfq))
#使用'abs()'取目标的绝对值
print(abs(-9))
#使用'bool'将目标转换为bool类型
print(bool(1))
#使用'divmod(x,y)'获取x除y得出的'(商,余数)'.可用在网页中的分页处理
print(divmod(9, 2))
#使用'max()'获取列表中的最大值
print(max([11,22,33,44]))
#使用'min()'获取列表中的最小值
print(min([11,22,33,44]))
#使用'sum()'对列表中的数据求和
print(sum([11,22,33,44]))
#使用'pow(x,y)'计算x的y次方
print(pow(2, 10))
#使用'len()'获取列表、字符串的长度。若是中文，则输出字节的长度
#使用'all()'对列表中的全部元素进行bool判断，全部为真则为True,否则为False
print(all([1,2,3,1]))
#使用'any()'对列表中的全部元素进行bool判断，全部为假则为False,否则为True
print(any([1,2,3,1]))
#依据输入的数字输出匹配的ASSIC字符
print(chr(66))
#依据输入的ASSIC字符输出匹配的数字。该功能可用于动态验证码生成方面。
print(ord('a'))
#依据输入的数字输出匹配的16进制数字
print(hex(17))
#依据输入的数字输出配置的8进制数字
print(oct(17))
#依据输入的数字输出匹配的2进制数字
print(bin(17))
#使用'enumerate()'为列表添加序号
#定义一个列表
goods = ['牙膏','牙缸','牙刷']
#为列表(goods)中的每个元素生成一个key,该key从1开始递增
for item in enumerate(goods,1):
    print(item)
#使用'format()'对字符串进行格式化(即为参数传值)操作.
#'{0}'代表第一个占位符，'{1}'代表第二个占位符，以此类推
s = 'is a {0}{1}'
print(s.format('alex',',a good teacher!'))
#使用'apply(函数的名称,函数参数的值)'执行函数
#使用'map(函数的名称,序列)'对序列内每一个元素遍历并作为参数传入函数内执行
def foo(arg):
    return arg + 100
li = [11,22,33]
temp = map(foo,li)
for item in temp:
    print(item)
#也可以在map里面使用匿名函数代替foo函数令代码更简洁
temp2 = map(lambda arg:arg + 100 ,li)
for item in temp2:
    print(item)
#使用'filter(函数的名称,序列)'对序列内的每一个元素遍历并作为参数传入函数执行，若返回结果为True,则加入新列表，否则则忽略。
def foo2(arg):
    if arg < 22:
        return True
    else:
        return False
temp3 = filter(foo2,li)
for item in temp3:
    print(item)
#使用'reduce(函数的名称,序列)'对序列内的每一个元素遍历并做累计（如加、乘等）计算
print(reduce(lambda arg1,arg2:arg1 + arg2,li))
print(reduce(lambda arg1,arg2:arg1 * arg2,li))
#使用'zip(序列1，序列2，序列3)'对n个序列内的每个元素遍历，并将相同索引号的元素混合形成一个新的序列
l1 = [1,2,3]
l2 = [4,5,6]
l3 = [7,8,9]
temp4 = zip(l1,l2,l3)
for item in temp4:
    print(item)
#将字符串类型的算法运算('8*8')处理并得出运算结果
#使用'eval(变量)'即可将字符串类型的算法运算得出结果
a = '8 * 8'
print(a)
print(eval(a))
#反射
#定义字符串(temp)等于字符串形式的os模块，如何通过字符串（temp）找到os模块使用非import方法导入
#使用'__import__'函数导入'temp'字符串形式的os模块
#常用于快速模块切换部分。若当前模块失效后，通过更改字符串形式的os模块，快速替换为功能相同的备用模块。
#如下所示，以字符串的形式导入模块，并以字符串的形式执行函数
temp = 'sys'
func = 'path'

model = __import__(temp)
#使用'getattr(模块,函数)'从sys模块中获取path函数
Function = getattr(model, func)
print(Function)
#等同于     'print(model.path)'

使用’hasattr(模块,函数)‘判断xx模块内是否包含xx函数
使用’delattr(模块,函数)’,从xx模块中删除xx函数

常用模块介绍

random用于生成随机数

#!/usr/bin/env python
#coding:utf-8

#random用于生成随机数
import random
from test.test_dis import CodeInfoTests
#随机生成一个0~1之间的随机数
print(random.random())
#随机生成一个1~2之间（包括1和2）的随机整数
print(random.randint(1,2))
#随机生成一个1~10之间（不包括10）的随机整数
print(random.randrange(1,10))

验证码的实现过程思路

#!/usr/bin/env python
#coding:utf-8

#定义一个空列表code
code = []
#通过循环6次生成一个包含6个元素的列表code
for i in range(6):
    #若第i次循环等于本次的随机整数，则将本次的随机整数插入到code列表内
    if i == random.randint(1,5):
        #将本次的随机整数使用'str(整数)'转换为字符串类型插入到code列表中
        code.append(str(random.randint(1,5)))
    else:
        #若不等于，随机生成一个65~90之间的随机整数并使用'chr(整数)'转换为字母
        temp = random.randint(65,90)
        code.append(chr(temp))
#将包含全字符串类型的列表转换为字符串（验证码样式）。
print(''.join(code))

‘join’ 与 ‘+=’ 字符串拼接方式的区别，‘join’效率最高，因为’+='方式每执行一次，都需在内存开辟一块空间，而’join’方式仅需开辟一次就好了。因此建议使用join方法。

md5加密

#!/usr/bin/env python
#coding:utf-8

#md5加密操作过程
import hashlib
#创建md5对象
hash = hashlib.md5()
#需要加密的数据
username = 'duanfuqiang'
# 对需要加密的数据进行encode操作
usernameEncode = username.encode(encoding = 'utf-8')
#使用update函数进行加密
hash.update(usernameEncode)
#输出加密后的数据
print(hash.hexdigest())
print(hash.digest())
# 若没有对加密数据进行encode操作， 则 报错为： Unicode-objects must be encoded before hashing
# 因为python3里默认的str是unicode
# 或者 b = bytes(str, encoding='utf-8')，作用相同，都是encode为bytes
print('MD5加密前为 ：' + username)
print('MD5加密后为 ：' + hash.hexdigest())

# 第二种写法：b‘’前缀代表的就是bytes
usernameMd5SecondWays = hashlib.md5(b'duanfuqiang').hexdigest()
print('第二种写法的MD5加密后为 ：' + usernameMd5SecondWays)

‘hash.hexdigest()’ 与 ‘hash.digest()’ 的区别是’hash.hexdigest()'比’hash.digest()'的输出长度短.

序列化与反序列化

#!/usr/bin/env python
#coding:utf-8

#序列化可以理解为其以特殊的二进制形式进行对类、对象、列表等实现加密（或序列化）的过程，且可逆转。
import  pickle
#定义一个列表
li = ['alex',11,22,'ok','ck']
#对列表进行序列化操作，返回类型为bytes类型
print(pickle.dumps(li))
print(type(pickle.dumps(li)))
dumped = pickle.dumps(li) 
#对返回结果进行反序列化处理
dumpedReturn = pickle.loads(dumped)
print(dumpedReturn)
print(type(dumpedReturn))
#对列表进行序列化操作，并将结果存储在特定文档内
#原因为：Python3给open函数添加了名为encoding的新参数，而这个新参数的默认值却是‘utf-8’。这样在文件句柄上进行read和write操作时，系统就要求开发者必须传入包含Unicode字符的实例，而不接受包含二进制数据的bytes实例。  
#解决方法：  使用二进制写入模式（‘wb’）来开启待操作文件，而不能像原来那样，采用字符写入模式（‘w’）
pickle.dump(dumped,open('D:/temp.txt', 'wb'))
#逆向从文件中读取序列化的数据并逆向还原数据
dumpOrigin = pickle.load(open('D:/temp.txt','rb'))
dumpOrigin2 = pickle.loads(dumpOrigin)
print(dumpOrigin2)

常应用在多个不同python程序间传输数据（共享一个文件），读取同一个序列化文件的场景。
通过读取同一个文件内存储的序列化数据，实现了两个独立python程序之间的内存数据的交互。
通过把内存中全部数据序列化后存储在本地硬盘，实现了对python程序内部全部内存数据在硬盘的存储

JSON

#!/usr/bin/env python
#coding:utf-8

import json
#定义一个字典
dicExample = {'name':'hanbing','age':18}
print(dicExample)
#使用json对字典进行序列化操作
dicJSON = json.dumps(dicExample)
print(dicJSON)
#使用json进行反序列化操作
dicOrigin = json.loads(dicJSON)
print(dicOrigin)

JSON与pickle(序列化)的区别
1.pickle仅适用于python语言；JSON是全部编程语言均支持的数据接口格式
2.pickle不仅可以dump常规的数据类型（如字典、列表等），还可以对类和对象序列化操作，对python中几乎所有的数据类型均能序列化操作；JSON仅能序列化常规的数据类型（如字典、列表、集合等）
3.pickle序列化的数据默认无法人为直接读懂；JSON序列化的数据可以人为直接看懂

re 正则表达式

常用的正则表达式

• 字符
  “\d” :代表数字
  “\w” :代表下划线、字母、数字、中横杠
  "\t " :代表制表符（除了回车以外的所有字符）
• 次数
  “*” :大于等于0
  “+” :大于等于1
  “?” :0或1
  “{m}” :出现m次数的匹配
  “{m,n}” :出现次数大于等于m次数，且出现次数小于等于n次数的匹配

#!/usr/bin/env python
#coding:utf-8
#导入're'模块，使用正则表达式
import re

#re.match(匹配规则, 目标字符串)
resultMatch = re.match('\d+', '111qwe123qwe321ewq')
resultSearch = re.search('\d+', '111qwe123qwe321ewq')
print(resultMatch)
#输出匹配成功部分的值
print(resultMatch.group())
print(resultSearch)
#match与search的区别，'match'仅从目标字符串起始开头位置匹配并输出匹配结果；search在整个目标字符串范围内匹配并输出匹配结果
#re.findall(匹配规则, 目标字符串),'findall'在整个目标字符串范围内匹配并输出全部的匹配结果
resultFindall = re.findall('\d+', '111qwe123qwe321ewq')
#输出匹配成功的全部结果的一个列表
print(resultFindall)
#使用're.compile('匹配规则')'，对匹配表达式进行编译操作(生成对象)
#常用于正则表达式重复使用的场景。通过编译生成对象使用对象，实现一次编译重复执行（使用）的效果，提高代码执行效率
resultCompile = re.compile('\d+')
#匹配表达式经过编译后，输出对象类型数据
print(type(resultCompile))
resultByCompile = resultCompile.findall('111qwe123qwe321ewq')
print(resultByCompile)
#groups：即分组
#'\w':代表下划线、字母、数字、中横杠
#'\d':代表数字
#'*'：代表零到多个
#'+'：代表至少有一个
resultGroups = re.search('(\d+)\w*(\d+)','111qwe123qwe321ewq')
#group:输出目标字符串所有符合正则表达式的结果
print(resultGroups.group())
#groups:仅输出组内（括号'(\d+)'内匹配的）匹配的结果（非重复的）
print(resultGroups.groups())

正则表达式实现IP地址过滤思路

#!/usr/bin/env python
#coding:utf-8
#导入're'模块，使用正则表达式
import re
#定义一个需要匹配的字符串
ip = 'time="2017-08-04T04:27:18+08:00" level=debug msg="handlePacket[79] : text mesage : {200/2722/2720/:-) CalleeAccept u? :-)\n\n1bea1d73\n\n2720\n\nwww.xingfafa.com:8443/`0} (192.168.1.101:33160)" '
#定义正则表达式
ipResult = re.findall('[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}',ip)
print(ipResult)
#定义正则表达式（第二种方法）
ipResult2 = re.findall('(?:\d{1,3}\.){3}\d{1,3}',ip)
print(ipResult2)

time模块

三种表示方式

• 时间戳 ：1970年1月1日之后的秒
• 元组 : 包含了年、月、日、星期等。例：time.struct_time
• 格式化的字符串 : 201900029 。例： print time.time()

#!/usr/bin/env python
#coding:utf-8
#导入'time'模块，使用time模块
import time
from _datetime import datetime
'''首先，我们先了解以下几个时间模块的概念
时间戳示例(float)
输出1970年1月1日之后的秒，即输出unix时间戳
常用于做日志分析工作时，将常规的时间格式转化时间戳的格式，简化日志过滤、分析过程，提高分析效率
'''
print(time.time())
##1567081590.4827812

'''
元组(结构化的)字符串时间示例(time.struct_time)
#输出元组(结构化的)字符串形式的时间展示
'''
print(time.gmtime())
print(time.localtime())
##time.struct_time(tm_year=2019, tm_mon=8, tm_mday=29, tm_hour=14, tm_min=8, tm_sec=9, tm_wday=3, tm_yday=241, tm_isdst=0)
##time.struct_time(tm_year=2019, tm_mon=8, tm_mday=29, tm_hour=22, tm_min=8, tm_sec=9, tm_wday=3, tm_yday=241, tm_isdst=0)

'''
字符串形式时间示例(str)
#输出字符串形式时间的时间展示
'''
print(time.strftime('%Y/%m/%d %H:%M:%S'))
print(type(time.strftime('%Y/%m/%d %H:%M:%S')))
##2019/08/29 22:04:49
##<class 'str'>

'''
时间格式形式时间示例(datetime.datetime)
'''
print(datetime.strptime('2001/01/01', '%Y/%m/%d'))
print(type(datetime.strptime('2001/01/01', '%Y/%m/%d')))
#2001-01-01 00:00:00
#<class 'datetime.datetime'>


#传入字符串形式时间，输出结构化形式时间
print(time.strptime('2001/01/01', '%Y/%m/%d'))
##time.struct_time(tm_year=2001, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=1, tm_isdst=-1)
#传入结构化形式时间，输出时间戳形式时间
print(time.mktime(time.localtime()))
##1567086107.0

时间戳、结构化形式时间、字符串形式时间、时间格式形式时间的相互转换

过程A

#!/usr/bin/env python
#coding:utf-8
#导入'time'模块，使用time模块
import time
#定义字符串形式时间
strTime = '2001-01-01 01:01:01'
print(strTime)
##2001-01-01 01:01:01
print(type(strTime))
##<class 'str'>
print(time.mktime(time.strptime(strTime,'%Y-%m-%d %H:%M:%S')))
##978282061.0

过程B

#!/usr/bin/env python
#coding:utf-8
#导入'time'模块，使用time模块
import time
from test.test_buffer import struct
#定义时间戳形式时间
floatTime = 978282061.0
print(floatTime)
##978282061.0
structTime = time.gmtime(floatTime)
print(structTime)
##time.struct_time(tm_year=2000, tm_mon=12, tm_mday=31, tm_hour=17, tm_min=1, tm_sec=1, tm_wday=6, tm_yday=366, tm_isdst=0)
strTime = time.strftime('%Y-%m-%d %H:%M:%S',structTime)
print(strTime)
print(type(strTime))
##2000-12-31 17:01:01
##<class 'str'>

过程C

#!/usr/bin/env python
#coding:utf-8
#导入'time'模块，使用time模块
import time
from _datetime import datetime
#定义时间戳形式时间
floatTime = 978282061.0
print(floatTime)
##978282061.0
structTime = time.gmtime(floatTime)
print(structTime)
##time.struct_time(tm_year=2000, tm_mon=12, tm_mday=31, tm_hour=17, tm_min=1, tm_sec=1, tm_wday=6, tm_yday=366, tm_isdst=0)
strTime = time.strftime('%Y-%m-%d %H:%M:%S',structTime)
print(strTime)
print(type(strTime))
##2000-12-31 17:01:01
##<class 'str'>
datetimeTime = datetime.strptime(strTime,'%Y-%m-%d %H:%M:%S')
print(datetimeTime)
print(type(datetimeTime))
##2000-12-31 17:01:01
##<class 'datetime.datetime'>

过程D

#!/usr/bin/env python
#coding:utf-8
#导入'time'模块，使用time模块
import time
from _datetime import datetime
#定义时间格式形式时间
datetimeTime = datetime.utcnow()
print(datetimeTime)
print(type(datetimeTime))
##2019-08-29 15:00:40.891493
##<class 'datetime.datetime'>
strTime = datetimeTime.strftime('%Y-%m-%d %H:%M:%S')
print(strTime)
print(type(strTime))
##2019-08-29 15:00:40
##<class 'str'>
structTime = time.strptime(strTime, '%Y-%m-%d %H:%M:%S')
print(structTime)
##time.struct_time(tm_year=2019, tm_mon=8, tm_mday=29, tm_hour=15, tm_min=1, tm_sec=25, tm_wday=3, tm_yday=241, tm_isdst=-1)
floatTime = time.mktime(structTime)
print(floatTime)
##1567062085.0

过程E

#!/usr/bin/env python
#coding:utf-8
#导入'time'模块，使用time模块
import time
from _datetime import datetime
#定义字符串形式时间
strTime = '2001-01-01 01:01:01'
print(strTime)
print(type(strTime))
##2001-01-01 01:01:01
##<class 'str'>
datetimeTime = datetime.strptime(strTime,'%Y-%m-%d %H:%M:%S')
print(datetimeTime)
print(type(datetimeTime))
##2001-01-01 01:01:01
##<class 'datetime.datetime'>

过程F

#!/usr/bin/env python
#coding:utf-8
#导入'time'模块，使用time模块
import time
from _datetime import datetime
#定义时间格式形式时间
datetimeTime = datetime.utcnow()
print(datetimeTime)
print(type(datetimeTime))
##2019-08-29 15:00:40.891493
##<class 'datetime.datetime'>
strTime = datetimeTime.strftime('%Y-%m-%d %H:%M:%S')
print(strTime)
print(type(strTime))
##2019-08-29 15:00:40
##<class 'str'>

python在导入(import)某个模块后，第二次导入该模块时，不会再做重复的工作。

常用函数

装饰器

作业