python学习随笔(六)_解析式_生成器

解析式,生成器

标准库 datetime
#from datetime import datetime
datetime.now()

datetime模块
    对日期，时间，时间戳的处理
    datetime类
        today()    #返回本地时区当前时间的datetime对象
            d1 = datetime.today()
***        now()    #常用，返回当前时间的datetime对象，时间到微秒，如果tz为None，返回和today()一样
            d1 = datetime.now()
        utconw()    #没有失去的当前时间
            d1 = datetime.utconw()
        fromtimestamp(timestamp, tz=None) 从一个时间戳返回一个datetime对象
            d3 = datetime.fromtimestamp(int(d1.timestamp()))
    datetime对象
***        timestamp()    返回一个到微秒的时间戳    #最常用
            d1.timestamp()
            时间戳:格林威治时间1970年1月1日0点到现在的秒数
        构造方法 d5 = datetime.datetime(2016, 12, 6, 16, 29, 43, 79043)
            year、month、day、hour、minute、second、microsecond，取datetime对象的年月日分秒及微秒
        d5.weekday() 返回星期的天，周一0，周日6
        d5.isoweekday() 返回星期的天，周一1，周日7
        d5.date() 返回日期date对象
        d5.time() 返回时间time对象
        d5.replace() 修改并返回新的时间
        d5.isocalendar() 返回一个三元组(年，周数，周的天)


日期格式化***        #str => datetime 从字符串解析成时间对象,前后格式必须相对,前面有空格,后面也要队友有空格
#年%y小写取两位  大写%Y取四位
    类方法 strptime(date_string, format) ，返回datetime对象
        d5 = datetime.strptime('2018,8,20,19,38,23','%Y,%m,%d,%H,%M,%S')
    对象方法 strftime(format),返回字符串    #大部分用这种得到一个字符串
        d4.strftime('%Y/%m-%d     %H:%M:%S')
    字符串format函数格式化
        print("{0:%Y}/{0:%m}/{0:%d} {0:%H}::{0:%M}::{0:%S}".format(dt))


timedelta对象    #表示一个区间 两个时间的增量
    datetime2 = datetime1 + timedelta
    datetime2 = datetime1 - timedelta
    timedelta = datetime1 - datetime2
    构造方法
        datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0,minutes=0, hours=0, weeks=0)
year = datetime.timedelta(days=365)
days =datetime.timedelta(seconds=5)
d1 + days     #加五秒

***对象下有一个方法 total_seconds    #常用
delta = (datetime.now()-start).total_seconds()

标准库time
     time
        time.sleep(secs)    #将调用线程挂起指定秒数


--------------------------------------------------------------------------------------
列表解析式    #构造列表时候用

语法
    [返回值 for 元素 in 可的迭代对象 if 条件]
    使用中括号,内部for循环,if条件语句可选
    返回一个新列表
模版:[(i+1)**2 for i in range(10)]

列表解析式是一种语法糖
    编译器会优化，不会因为简写而影响效率，反而因优化提高了效率
    减少程序员工作量，减少出错
    简化了代码，但可读性增强
even = [x for x in range(10) if x%2 == 0]

ret = [expr for i in iterable1 for j in iterable2 ]
等价于:
ret = []
for i in iterable1:
for j in iterable2:
ret.append(expr)

生成器表达式
     语法
        (返回值 for 元素 in 可迭代对象 if 条件)
        列表解析式的中括号换成小括号就行了
        返回一个生成器
    和列表解析式的区别
         生成器表达式是按需计算（或称惰性求值、延迟计算），需要的时候才计算值
         列表解析式是立即返回值
    生成器
        可迭代对象
        迭代器
模版:g = ("{:04}".format(i) for i in range(1,11))

集合解析式
    语法
        {返回值 for 元素 in 可迭代对象 if 条件}
        列表解析式的中括号换成大括号{}就行了
        立即返回一个集合
    用法
         {(x,x+1) for x in range(10)}
        {[x] for x in range(10)} #
字典解析式
    语法
        {返回值 for 元素 in 可迭代对象 if 条件}
        列表解析式的中括号换成大括号{}就行了
        使用key:value形式
        立即返回一个字典
    用法
        {x:(x,x+1) for x in range(10)}
        {x:[x,x+1] for x in range(10)}
        {(x,):[x,x+1] for x in range(10)}
        {[x]:[x,x+1] for x in range(10)} #这个是错的,key必须可hash
        {chr(0x41+x):x**2 for x in range(10)}#返回字符串可hash,41大写的61小写的,进行ASCII比较 小写a大
        {str(x):y for x in range(3) for y in range(4)} #去重{'0': 3, '1': 3, '2': 3}


-----------------------------------------------------------------------------------
内建函数
id()    #返回对象为一标识,Cpython返回内存地址
hash()    #返回一个对象哈希值
type()    #返回对象的类型
类型转换:float(),int(),bin(),hex(),oct(),bool(),list(),tuple(),dict(),set(),complex(),bytes(),bytearray()
输入:input()

打印:print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
? 打印输出，默认使用空格分割、换行结尾，输出到控制台

对象长度:len()

前面是对象,后面是类型,也可以把类型放在元组里去,依次与元组里的类型比较
如果是返回True 不是返回False
isinstance(obj, class_or_tuple)#判断对象obj是否属于后面那个类型
isinstance(True, int)
isinstance([1,2],list)
isinstance([1,2],(list,str))

issubclass(cls, class_or_tuple)# 判断类型cls,shibus 后面的子类
issubclass(bool,int)

abs()    #绝对值
最大值max() 最小值min()

round()    #四舍六入五取偶

pow(x,y)    #x**y

range()    #从0开始到stop-1的可迭代对象

divmod(x,y)等价于tuple(x//y,x%y)

sum(iterable[,start])对迭代对象的所有元素求和
sum(range(1,100,2))

chr(i) #给一个一定范围的整数返回对应的字符
    chr(97) chr(20013)

ord(c) 返回字符对应的整数
    ord('a') ord('中')

***str() 、repr()、ascii() 后面说

sorted(iterable[, key][, reverse]) 排序    #立即求值
    # 返回一个新的列表，默认升序
    # reverse是反转 #sorted([1, 5,3, ], reverse=True)

翻转 reversed(seq)    #返回一个翻转元素的迭代器
list(reversed("13579"))    #立即形成列表
{reversed("13579")}        #返回迭代器


枚举 enumerate(seq, start=0)
迭代一个序列，返回索引数字和元素构成的二元组
start表示索引开始的数字，默认是0

enumerate(range(10,15))    #返回迭代器
enumerate(range(10,15),10)    #表示索引从10开始配对
#(10,10)-(14, 14)

只有next()函数里面要求是个迭代器
其他函数要求是个可迭代对象就行


迭代器和取元素 iter(iterable)、next(iterator[, default])
iter()    #将一个可迭代对象封装成一个迭代器,是迭代器就什么都不做了

nex()    #t对一个迭代器取下一个元素。如果全部元素都取过了，再次next会抛StopIteration异常
给设置个缺省值,就不会抛异常而是返回缺省值


可迭代对象
    能够通过迭代一次次返回不同的元素的对象    #所谓相同，不是指值是否相同，而是元素在容器中是否是同一个

    可以迭代，但是未必有序，未必可索引
    可迭代对象有：list、tuple、string、bytes、bytearray、range、set、dict、生成器等
    可以使用成员操作符in、not in，in本质上就是在遍历对象
3 in {x:y for x,y in zip(range(4),range(4,10))}#在字典中in效率高,因为是hash的


迭代器
    特殊的对象，一定是可迭代对象，具备可迭代对象的特征
    可以用个iter()将一个可迭代对象包装成迭代器,可以通过next()迭代迭代器
    生成器对象，就是迭代器对象

拉链函数zip(*iterables)    #取最短的
    像拉链一样，把多个可迭代对象合并在一起，返回一个迭代器
    将每次从不同对象中取到的元素合并成一个元组
list(zip(range(10),range(10),range(5),range(10)))
dict(zip(range(10),range(10)))
{str(x):y for x,y in zip(range(10),range(10))}

转载于:https://www.cnblogs.com/springquanquan/p/9573766.html