9内置函数

迈不过友情╰ 2022-01-10 22:55 263阅读 0赞

内置函数

标准库，namespace名称空间；

datetime，对日期、时间、时间戳的处理：

datetime类：类方法；datetime对象；

类方法：

today()，返回本地时区当前时间的datetime对象；

now(tz=None)，返回当前时间的datetime对象，时间到微秒，如果tz为None，返回和today()一样；

utcnow()，没有时区的当前时间；

fromtimestamp(timestamp,tz=None)，从一个时间戳返回一个datetime对象；

datetime对象：

timestamp()，返回一个到微秒的时间戳；

构造方法：

In \[14\]: a=datetime.datetime(2018,3,26,19,12,29,79043)   \#year,month,day,hour,minute,second,microsecond，取datetime对象的年月日时分秒微秒

In \[15\]: a

Out\[15\]: datetime.datetime(2018, 3, 26, 19, 12, 29, 79043)

In \[16\]: a=datetime.datetime(2018,3,26)   \#至少要给year,month,day，hour,minute会补0

In \[17\]: a

Out\[17\]: datetime.datetime(2018, 3, 26, 0, 0)

weekday()，返回星期的天，周一0，周日6，如a.weekday()；

isoweekday()，返回星期的天，周一1，周日7，如a.isoweekday()；

date()，返回日期date对象，a,date()；

time()，返回时间time对象，a.time()；

replace()，修改并返回新的时间；

isocalendar()，返回一个三元组（年、周数、周的天），a.isocalendar()；

注：

编程时一般都不设置时区；

时间戳，格林威治时间1970-1-1，0点到现在的秒数，与时区无关；

例：

In \[1\]: import datetime

In \[2\]: datetime.datetime.now()

Out\[2\]: datetime.datetime(2018, 3, 26, 19, 3, 12, 8146)

In \[3\]: datetime.datetime.today()

Out\[3\]: datetime.datetime(2018, 3, 26, 19, 3, 23, 298291)

In \[4\]: datetime.datetime.utcnow()

Out\[4\]: datetime.datetime(2018, 3, 26, 11, 3, 42, 720141)

In \[5\]: a=datetime.datetime.now()

In \[6\]: a.timestamp()

Out\[6\]: 1522062256.146931

In \[7\]: type(a)

Out\[7\]: datetime.datetime

In \[8\]: a=a.timestamp()

In \[9\]: type(a)

Out\[9\]: float

In \[10\]: b=datetime.datetime.fromtimestamp(a)

In \[11\]: b

Out\[11\]: datetime.datetime(2018, 3, 26, 19, 4, 16, 146931)

In \[12\]: b=datetime.datetime.fromtimestamp(int(a))   \#微秒丢了

In \[13\]: b

Out\[13\]: datetime.datetime(2018, 3, 26, 19, 4, 16)

In \[14\]: a=datetime.datetime(2018,3,26,19,12,29,79043)

In \[15\]: a

Out\[15\]: datetime.datetime(2018, 3, 26, 19, 12, 29, 79043)

In \[16\]: a=datetime.datetime(2018,3,26)

In \[17\]: a

Out\[17\]: datetime.datetime(2018, 3, 26, 0, 0)

In \[18\]: a.weekday()

Out\[18\]: 0

In \[19\]: a.isoweekday()

Out\[19\]: 1

In \[20\]: a.date()

Out\[20\]: datetime.date(2018, 3, 26)

In \[21\]: a.time()

Out\[21\]: datetime.time(0, 0)

In \[22\]: a.isocalendar()

Out\[22\]: (2018, 13, 1)

日期格式化：

类方法，datetime.datetime.strptime(date\_string,format)，返回datetime对象，new datetime parsed from a string；

对象方法，a.strftime(format)，返回字符串，string format；

字符串format函数格式化；

例：

In \[37\]: dt=datetime.datetime.strptime('27/3/18 9:30','%d/%m/%y %H:%M')   \#类方法，返回datetime对象，%y（小写短的），%Y（大写长的）

In \[38\]: dt

Out\[38\]: datetime.datetime(2018, 3, 27, 9, 30)

In \[39\]: dt.strftime('%Y-%m-%d %H:%M:%S')   \#对象方法

Out\[39\]: '2018-03-27 09:30:00'

In \[40\]: '\{0:%Y\}/\{0:%m\}/\{0:%d\} \{0:%H\}:\{0:%M\}:\{0:%S\}'.format(dt)   \#要加0，否则位置对不上

Out\[40\]: '2018/03/27 09:30:00'

In \[41\]: '\{\}/\{\}/\{\}'.format(dt.year,dt.month,dt.day)   \#常用

Out\[41\]: '2018/3/27'

timedelta对象，时间差对象：

构造方法：datetime.timedelta(days=0,seconds=0,microseconds=0,milliseconds=0,minutes=0,hours=0,weeks=0)

year=datetime.timedelta(days=365)

total\_seconds()，返回时间差的总秒数；

例：

In \[44\]: d=datetime.timedelta(days=1)   \#构造时间差为1天

In \[45\]: d

Out\[45\]: datetime.timedelta(1)

In \[46\]: h=datetime.timedelta(hours=24)   \#构造时间差为1天

In \[47\]: h

Out\[47\]: datetime.timedelta(1)

In \[48\]: datetime.datetime.now()-d

Out\[48\]: datetime.datetime(2018, 3, 26, 10, 4, 0, 842544)

In \[49\]: d1=datetime.datetime.now()

In \[50\]: d2=datetime.datetime.now()

In \[51\]: td=d2-d1

In \[52\]: td.total\_seconds()

Out\[52\]: 8.391767

In \[53\]: (datetime.datetime.now()-d1).total\_seconds()

Out\[53\]: 72.024944

标准库，time；

id()，标识，返回对象的唯一标识，cpython返回内存地址；

hash()，哈希，返回一个对象的哈希值，散列值（定义域、值域、哈希空间、散列空间、根据哈希算法，哈希冲突少的算法好）；

type()，类型，返回对象的类型；

float(),int(),bin(),hex(),oct(),bool(),list(),tuple(),dict(),set(),complex(),bytes(),bytearray()，类型转换；

input(\[prompt\])，输入，接收用户输入，返回一个字符串；

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

len()，对象长度，返回一个集合类型的元素个数；

isinstance(obj,class\_or\_tuple)，判断对象是否属于某种类型或元组中列出某个类型；

issubclass(cls,class\_or\_tuple)，判断类型cls是否是某种类型的子类或元组中列出的某个类型的子类；

In \[4\]: issubclass(bool,int)

Out\[4\]: True

abs(num)，绝对值，num为数值；

max(),min()，返回可迭代对象中最大值和最小值，返回多个参数中最大值和最小值；

round(num)，四舍六入五取偶，银行家算法；

pow(x,y)，等价于x\*\*y；

range(stop)，从0开始到stop-1的可迭代对象，不是迭代器；

range(start,stop\[,step\])，从start开始到stop-1结束步长为step的可迭代对象；

divmod(x,y)，等价于tuple(x//y,x%y)，divmod(3,5)；

sum(iterable\[,start\])，对可迭代对象的所有数值元素求和，sum(range(1,100,2)，累加；

chr(i)，给一个一定范围的整数返回对应的字符，Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.；

ord(c)，返回字符对应的整数，Return the Unicode code point for a one-character string.；

str()，呈现字符串的表达形式，\_\_str\_\_()魔术方法；

repr(),ascii()；

例：

In \[1\]: isinstance(False,(bool,int,str))

Out\[1\]: True

In \[2\]: isinstance(False,int)

Out\[2\]: True

In \[3\]: isinstance(True,int)

Out\[3\]: True

In \[5\]: round(-0.5)

Out\[5\]: 0

In \[6\]: round(-0.6)

Out\[6\]: -1

In \[7\]: round(-0.4)

Out\[7\]: 0

In \[8\]: divmod(3,5)

Out\[8\]: (0, 3)

In \[9\]: sum(range(1,100,2))

Out\[9\]: 2500

In \[10\]: sum(range(1,100,2),50)   \#起始数先加进来

Out\[10\]: 2550

In \[14\]: chr(97)

Out\[14\]: 'a'

In \[15\]: chr(20013)

Out\[15\]: '中'

In \[16\]: ord('a')

Out\[16\]: 97

In \[17\]: ord('中')

Out\[17\]: 20013

In \[18\]: ord('国')

Out\[18\]: 22269

In \[19\]: hex(ord('国'))

Out\[19\]: '0x56fd'

In \[20\]: str(5)

Out\[20\]: '5'

In \[21\]: repr(5)

Out\[21\]: '5'

In \[22\]: ascii(5)

Out\[22\]: '5'

In \[23\]: ascii('a')

Out\[23\]: "'a'"

In \[24\]: str('a')

Out\[24\]: 'a'

In \[25\]: repr('a')

Out\[25\]: "'a'"

sorted(iterable\[,key\]\[,reverse\])-->list，排序，返回一个新列表，默认升序，reverse反转；如果lst.sort()在列表上用sort()方法是就地修改，返回值为None，a=lst.sort()相当于a=None这样写没意义；

reversed(seq)-->list\_reverseiterator，返回一个翻转元素的迭代器；

enumerate(seq,start=0)-->iterator for index,iterator for value，迭代一个序列，返回索引数字和元素构成的二元组，start索引开始的数字，默认0；

iter(iterable)，将一个可迭代对象封装成一个迭代器；

next(iterator)，取元素，对一个迭代器取下一个元素，如果元素全部取完，再next()会抛StopIteration异常；

zip(\*iterables)，拉链函数，像拉链一样，把多个可迭代对象合并在一起，返回一个迭代器，将每次从不同对象中取到的元素合并成元组，一般用于dict，dict(zip('abcde',range(5)))木桶原理；

可迭代对象：

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

可以迭代，但是未必有序，未必可索引；

可迭代对象有，list,tuple,string,bytes,bytearray,range,set,dict,iterator等；

可用成员运算符in,not in，in本质上就是在遍历对象；

迭代器：

特殊的对象，一定是可迭代对象，具备可迭代对象的特征；

通过iter(iterable)把一个可迭代对象封装成迭代器；

通过next()迭代迭代器对象；

生成器对象，就是迭代器对象；

迭代器不一定是生成器；

例：

In \[30\]: lst=\[3,1,5\]

In \[31\]: sorted(lst)

Out\[31\]: \[1, 3, 5\]

In \[32\]: sorted(lst,reverse=True)

Out\[32\]: \[5, 3, 1\]

In \[33\]: a=sorted(lst,reverse=True)

In \[34\]: a

Out\[34\]: \[5, 3, 1\]

In \[36\]: sorted(\{'b':2,'a':1\})   \#只对dict的key排序

Out\[36\]: \['a', 'b'\]

In \[37\]: a=reversed(\[3,5,1\])

In \[38\]: a

Out\[38\]: <list\_reverseiterator at 0x7fa0dd064c50>

In \[39\]: next(a)

Out\[39\]: 1

In \[40\]: next(a)

Out\[40\]: 5

In \[41\]: next(a)

Out\[41\]: 3

In \[42\]: \[reversed(\[3,5,1\])\]   \#不是列表解析，是list\_reverseiterator

Out\[42\]: \[<list\_reverseiterator at 0x7fa0dd061518>\]

In \[43\]: \[i for i in reversed(\[3,5,1\])\]   \#列表解析

Out\[43\]: \[1, 5, 3\]

In \[44\]: \{reversed((2,4))\}   \#该集合元素几个？1个，仅list\_reverseiterator对象本身

Out\[44\]: \{<reversed at 0x7fa0dd064668>\}

In \[45\]: (reversed(\['c','b','a'\]))   \#最外层()没用，reversed(seq)本身返回的就是迭代器对象

Out\[45\]: <list\_reverseiterator at 0x7fa0dcfe9eb8>

In \[49\]: for i in reversed(sorted(\{1,5,9\})):   \#反转中间结果

...:     print(i)

...:

In \[50\]: for i in enumerate(\[2,4,6\]):

...:     print(i)

...:

(0, 2)

(1, 4)

(2, 6)

In \[52\]: for k,v in enumerate('mno'):   \#解构

...:     print(k,v)

...:

0 m

1 n

2 o

In \[61\]: it=iter(range(2))

In \[62\]: next(it)

Out\[62\]: 0

In \[63\]: next(it)

Out\[63\]: 1

In \[64\]: next(it)

\---------------------------------------------------------------------------

StopIteration                             Traceback (most recent call last)

<ipython-input-64-bc1ab118995a> in <module>()

\----> 1 next(it)

StopIteration:

In \[65\]: 3 in range(10)

Out\[65\]: True

In \[66\]: 3 in (x for x in range(10))

Out\[66\]: True

In \[67\]: 3 in \{x:y for x,y in zip(range(4),range(4,10))\}   \#匹配key

Out\[67\]: True

In \[71\]: \{x:y for x,y in zip('abcd',range(4))\}

Out\[71\]: \{'a': 0, 'b': 1, 'c': 2, 'd': 3\}

In \[72\]: \{x:y for x,y in zip('abcd',range(5,20))\}   \#zip()，木桶原理

Out\[72\]: \{'a': 5, 'b': 6, 'c': 7, 'd': 8\}

In \[73\]: for i in iter(range(3)):   \#可这样用

...:     print(i)

...:

In \[74\]: g=(i for i in range(4))

In \[75\]: g

Out\[75\]: <generator object <genexpr> at 0x7fa0dda6dfc0>

In \[76\]: print(type(g))

In \[77\]: list(zip('abcd',range(4)))

Out\[77\]: \[('a', 0), ('b', 1), ('c', 2), ('d', 3)\]

In \[78\]: list(zip('abcd',range(4),'efgh',range(5,9)))

Out\[78\]: \[('a', 0, 'e', 5), ('b', 1, 'f', 6), ('c', 2, 'g', 7), ('d', 3, 'h', 8)\]

In \[79\]: dict(zip('abcde',range(5)))

Out\[79\]: \{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4\}

In \[86\]: \{str(x):y for x,\_,y in zip(range(10),range(10),range(10,20))\}

Out\[86\]:

\{'0': 10,

'1': 11,

'2': 12,

'3': 13,

'4': 14,

'5': 15,

'6': 16,

'7': 17,

'8': 18,

'9': 19\}

In \[87\]: d=dict(zip('abcd',range(4)))

In \[88\]: d

Out\[88\]: \{'a': 0, 'b': 1, 'c': 2, 'd': 3\}

In \[89\]: d1=sorted(d.items(),reverse=True)   \#对二元组排序

In \[90\]: d1

Out\[90\]: \[('d', 3), ('c', 2), ('b', 1), ('a', 0)\]

注：

内置函数：map、filter、reversed、enumerate；

decorator；

generator；

mro中的mixin；

以上用的出神入化，中级水平；

转载于:https://blog.51cto.com/jowin/2388532

9内置函数

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 ORACLE 内置函数

相关【基础】内置函数

相关 python内置函数

相关 SparkSQL内置函数

相关 python内置函数

相关 python内置函数

相关 oracle内置函数

相关 9内置函数

相关 Hive内置函数

相关内置函数