第十五章,python全栈开发

Built-in Functions
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate()   
input() oct() staticmethod() 
bin() eval() int() open() str()
bool() exec() isinstance()  ord() sum()
bytearray() filter() issubclass()  pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property()    
type()
chr() frozenset() list() range() vars()
classmethod()  getattr() locals() repr() zip()
compile() globals() map() reversed()    
complex() hasattr() max() round()  
delattr() hash() memoryview() set()  

python有一些常用的内置函数:

一、内置函数

注意:内置函数id()可以返回一个对象的身份,返回值为整数。

这个整数通常对应与该对象在内存中的位置,但这与python的具体实现有关,不应该作为对身份的定义,即不够精准,最精准的还是以内存地址为准。

is运算符用于比较两个对象的身份,等号比较两个对象的值,内置函数type()则返回一个对象的类型

#更多内置函数:

图片 1

 

数学函数

二、内置函数详情

1、abs(x)

功能:取数的绝对值

1
2
>>> abs(-1)  #取-1的绝对值
1

2、all(iterable)

功能:如果这个可迭代的元素都为真,则返回真(非0的就为真,负数也是为真)

1
2
3
4
>>> all([0,9,-3])   #有0,说明为假
False
>>> all([-1,5,6])  #负数也是为真
True

3、any(iterable)

功能:可迭代的元素中,有一个为真,则返回真,没有真或空列表返回假。

1
2
3
4
>>> any([0,0,2])  #有一个为真,则为真
True
>>> any([])  #空列表为假
False

4、ascii(object)

功能:把内存对象变成一个可打印的字符串格式

1
2
>>> a = ascii([1,2,3,4])
>>> print(type(a),[a])

5、bin(x)

功能:把一个整数转换成二进制

1
2
3
4
>>> bin(300)  #把300转换成二进制
'0b100101100'
>>> bin(1)
'0b1'

6、bool([x])

功能:返回一个布尔值,空列表为假,不为空为真

1
2
3
4
5
6
>>> bool([])   #空列表
False
>>> bool([1,2])   #不为空列表
True
>>> bool([0])
True

7、bytearray[source[, encoding[, errors]]]

功能:字节数组,并且可以修改二进制的字节

1
2
3
4
5
6
>>> b = bytearray("abcd",encoding="utf-8")  #声明一个字节数组
>>> b[0]  #打印第一个元素的ascii值,也就是'a'对应的ascii值
97
>>> b[0= 100  #修改时,只能赋值对应字符的ascii值
>>> b
bytearray(b'dbcd')   #发现字节数组值被修改

8、bytes([source[, encoding[, errors]]])

功能:把字符串转换成字节

1
2
3
4
5
6
7
8
9
>>> b = bytes("abcd",encoding="utf-8")  #声明字节
>>> b
b'abcd'
>>> b[0]   #访问到'a'字符对应的ASCII值
97
>>> b[0]=100    #不可以修改里面的值,不然会报错
Traceback (most recent call last):
  File "<input>", line 1in <module>
TypeError: 'bytes' object does not support item assignment

9、callable(object)

功能:判断一个对象是否可以被调用,只有在后面有括号的,表示可以调用,比如:函数,类。

1
2
3
4
5
>>> callable([])  #列表后面不加括号
False
>>> def sayhi():pass  #定义一个函数
>>> callable(sayhi)  #函数调用,后面需要加括号
True

10、chr(i)

功能:通过ascii的值(必须是数字),找到对应的字符

1
2
>>> chr(97)
'a'

11、ord(c)

功能:根据字符(必须ascii的字符),找到对应的ascii值

1
2
>>> ord('a')
97

12、complex([real[, imag]])

功能:返回一个复数,我们几乎用不到。

1
2
>>> complex('1 2j')
(1 2j)

13、dict(*kwarg)、dict(mapping**kwarg)、dict(iterable**kwarg*)

功能:返回一个字典

1
2
3
4
5
6
7
8
>>> dict()  #定义一个字典
{}
>>> dict(name='qianduoduo',age=18)   #传入非固定关键字参数
{'name''qianduoduo''age'18}
>>> dict([('name','qianduoduo'),('age',18)])   #传入一个列表
{'name''zhangqigao''age'18}
>>> dict([['name','qianduoduo'],['age',18]])    #传入一个列表
{'name''qianduoduo''age'18}

 14、dir([object])

功能:看一个对象有哪些方法

1
2
3
4
5
6
7
8
>>> name = []
>>> dir(name)  #显示name下的所有的方法
['__add__''__class__''__contains__''__delattr__''__delitem__''__dir__''__doc__',
'__eq__''__format__''__ge__''__getattribute__''__getitem__''__gt__''__hash__',
'__iadd__''__imul__''__init__''__iter__''__le__''__len__''__lt__''__mul__''__ne__',
'__new__''__reduce__''__reduce_ex__''__repr__''__reversed__''__rmul__',
'__setattr__''__setitem__''__sizeof__''__str__''__subclasshook__''append''clear',
'copy''count''extend''index''insert''pop''remove''reverse''sort']

15、divmod(a,b)

功能:地板除,获得一个元组,元组第一个元素是商,第二个元素是余数。

1
2
>>> divmod(5,2)
(21)    #2是商,1是余数

16、enumerate(iterable,start=0)  购物车的列表用到了,

功能:遍历一个可迭代对象,获取索引和对应的元素的

1
2
3
4
5
>>> seasons = ['Spring''Summer''Fall''Winter']
>>> list(enumerate(seasons))
[(0'Spring'), (1'Summer'), (2'Fall'), (3'Winter')]
>>> list(enumerate(seasons, start=1))
[(1'Spring'), (2'Summer'), (3'Fall'), (4'Winter')]

 17、eval(expressionglobals=Nonelocals=None)

功能:把字典类型的字符串变成字典,把一个整数类型的字符变成int类型,或者加减乘除这种简单转换成表达式。

1
2
3
4
>>> eval('1')  #字符类型转换成int类型
1
>>> eval("1 3/2*6")   #字符串转换为表达式
10.0

18、filter(functioniterable)

功能:通过function过滤条件,去获取iterable中你想要的数据。

1
2
3
4
5
6
7
8
9
>>> res = filter(lambda n:n>5,range(10)) 
>>> res     #得到一个迭代器
<filter object at 0x0000000003093BE0>
>>> for in res:
    print(i)
6
7
8
9

19、map(functioniterable)

功能:对传入的每一个值进行处理,处理完了再返回,再把原来的结果覆盖掉。

1
2
3
4
5
6
7
8
9
10
>>> res = map(lambda n:n*2,range(5))  #n*2是处理方式
>>> res
<map object at 0x00000000031B4BE0>
>>> for in res:
    print(i)
0
2
4
6
8

20、reduce(function,iterable)

功能:把一组可迭代序列通过function函数操作,元素之间相加或者相乘操作。

1
2
3
4
5
6
7
>>> from functools import reduce
>>> res = reduce(lambda x,y:x y,range(10))  #x y的值赋给x,rang(10)中的每个元素赋给y
>>> res
45
>>> res = reduce(lambda x,y:x*y,range(1,10)) #x*y的值赋给x,rang(10)中的每个元素赋给y
>>> res
362880

21、float([x])

功能:把一个浮点类型的字符串转换为浮点类型的数据。

1
2
3
4
5
6
7
8
9
10
>>> float(' 1.23')
1.23
>>> float('   -12345n')
-12345.0
>>> float('1e-003')
0.001
>>> float(' 1E6')
1000000.0
>>> float('-Infinity')
-inf

22、format(value[, format_spec])

功能:格式话字符串,前面字符串拼接讲过

23、frozenset([iterable])

功能:把集合变成一个不可变的集合

1
2
3
4
5
6
7
8
9
10
>>> res = frozenset([1,2,3,4,3])
>>> res
frozenset({1234})   #去重的,不可变的集合
>>> dir(res)   #没有可变的方法
['__and__''__class__''__contains__''__delattr__''__dir__''__doc__''__eq__',
'__format__''__ge__''__getattribute__''__gt__''__hash__''__init__''__iter__''__le__',
 '__len__''__lt__''__ne__''__new__''__or__''__rand__''__reduce__''__reduce_ex__',
'__repr__''__ror__''__rsub__''__rxor__''__setattr__''__sizeof__''__str__''__sub__',
'__subclasshook__''__xor__''copy''difference''intersection''isdisjoint''issubset',
'issuperset''symmetric_difference''union']

 注:set()是可变的

24、globals()

功能:返回当前这个python文件中的所有变量的key-value,变量是key,值是value

1
2
3
4
5
6
7
print(globals())
 
#输出
{'__spec__'None'__name__''__main__''__file__': 'D:/PycharmProjects/pyhomework
/day4/内置函数/内置函数.py', '__doc__': None, '__package__': None, '__loader__':
<_frozen_importlib_external.SourceFileLoader object at 0x0000000000695B00>,
'__cached__'None'__builtins__': <module 'built

注:可以判断一个文件中的变量是否存在,而globals()只能打印全局变量

25、help([object])

功能:显示对象的帮助信息

1
2
3
4
5
6
7
8
9
10
11
>>> res = []  #定义一个列表
>>> help(res)   #打印帮助信息
Help on list object:
 
class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items
 
 |  Methods defined here:
 
 .....

26、hex(x)

功能:把一个数字转成16进制

1
2
3
4
>>> hex(255)
'0xff'
>>> hex(10)
'0xa'

27、id(object)

功能:返回对象的内存地址

1
2
>>> id('zhangqigao')
50993136   #'zhangqigao'这个字符串的内存地址

28、input([prompt])

功能:输入字符串

1
2
3
4
>>> s = input('--> '
--> Monty Python's Flying Circus  #输入的内容
>>> s 
"Monty Python's Flying Circus"

29、int(x)

功能:把其他数据类型强制转换成int类型

1
2
>>> int('10')
10

30、iter(object[, sentinel])

功能:把一个普通序列转成迭代器

1
2
3
with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)

31、len(s)

功能:计算序列或者字符串的长度

1
2
3
4
>>> len("zhangqigao")  #字符串的长度
10
>>> len([1,2,3,4,5])  #列表的长度
5

32、list([iterable])

功能:把其他序列转换成一个列表

1
2
>>> list((1,2,3,4,5))   #把一个元组转换为一个列表
[12345]

33、locals()

功能:打印局部变量

1
2
3
4
5
6
7
8
9
10
11
def test():
    locals_var = 333
    print(locals())   #只打印局部变量
 
test()
print(globals().get("locals_var"))  #只能打印全局变量
 
#输出
 
{'locals_var'333}
None

34、max(iterable**[, keydefault*])

功能:返回列表重点额最大值

1
2
>>> max([1,2,3,4,5])
5

35、min(iterable**[, keydefault*])

功能:返回列表中的最小值

1
2
>>> min([1,2,3,4,5])
1

36、next(iterator[, default])

功能:返回迭代器的下一个值,相当于__next__()方法,如果迭代最后一个数据之后没有值了,则会抛出一个StopIteration异常

1
2
3
4
5
6
7
8
9
>>> a = iter([1,2])
>>> next(a)
1
>>> next(a)
2
>>> next(a)
Traceback (most recent call last):
  File "<input>", line 1in <module>
StopIteration

37、object

功能:python中一切皆对象,每一个对象都有它的属性和方法

38、oct(x)

功能:把一个数转成8进制

1
2
3
4
5
6
7
8
>>> oct(7)
'0o7'
>>> oct(8)
'0o10'
>>> oct(15)
'0o17'
>>> oct(16)
'0o20'

39、open(filemode='r'buffering=-1encoding=Noneerrors=Nonenewline=Noneclosefd=Trueopener=None)

功能:文件操作,详细介绍:
]()

40、pow(xy[, z])

功能:返回多少次幂

1
2
>>> pow(2,3)  #相当于2**3
8

41、print(objectssep=' 'end='n'file=sys.stdoutflush=False*)

功能:打印

1
2
>>> print("zhangqigao")
zhangqigao

42、range(stop)、range(startstop[, step])

功能:生成一个迭代器

1
2
3
4
5
6
>>> range(5)
range(05)
>>> range(1,5)
range(15)
>>> range(1,5,2)
range(152)

43、reversed(seq)

功能:反转一个序列,跟列表中的reversed方法是一样的

1
2
3
4
5
6
7
8
9
10
>>> reversed([1,2,3,4,5])
<list_reverseiterator object at 0x00000000030A2588>  #变成一个迭代器
>>> for in  reversed([1,2,3,4,5]):
...     print(i)
...    
5
4
3
2
1

44、round(number[, ndigits])

功能:四舍五入

45、set([iterable])

功能:集合

46、slice(stop),slice(startstop[, step])

功能:序列的切片,方便多次反复切

1
2
3
4
5
>>> a = [1,2,3,4,5,6]
>>> a[slice(1,3)]
[23]
>>> a[1:3]
[23]

47、sorted(iterable[, key][, reverse])

功能:对一个序列进行排序

1
2
3
4
5
6
7
8
9
>>> sorted([5,3,2,6,8])
[23568]
>>> a = {1:5,6:8,3:6}
>>> sorted(a)  #默认是按key排序
[136]
>>> sorted(a.items())  #按key排序
[(15), (36), (68)]
>>> sorted(a.items(),key = lambda x:x[1])  #按value排序
[(15), (36), (68)]

48、 str(object)

功能:把其他数据类型转换为字符串

1
2
>>> str(1)
'1'

49、sum(iterable[, start])

功能:求一个列表的和,元组,集合,前提都是数字类型

1
2
>>> sum([1,2,3,4,5,6])
21

50、tuple([iterable])

功能:把其他序列转换为一个元组

1
2
>>> tuple([1,2,3,4,5])
(12345)

51、type(object) 、type(namebasesdict)

功能:查看一个对象的数据类型

1
2
3
>>> a = 'qianduoduo'
>>> type(a)
<class 'str'>

注:一切数据类型都是有type()方法产生,它是一切数据类型的根。

52、zip(iterables*)

功能:zip中文意思是拉链的意思,把两个序列一一对应起来。

1
2
3
4
5
6
7
8
9
>>> a = [1,2,3,4]
>>> b=['a','b','c','d']
>>> for in zip(a,b):
...     print(i)
...    
(1'a')
(2'b')
(3'c')
(4'd')

 注:如果a的元素比b的多,则按照元素最少的那个来 

PS:有些没有列出来,不是实在用不着,就是后面类的重点,后面还有单独的博客!

abs(x)

  求一个数的绝对值。

>>> abs(13)
13
>>> abs(-15)
15

abs() 获取绝对值

all(iterable)

  如果迭代器中的所有值都为“真”则返回 True, 否则返回 False

  注意: 如果迭代器为空,返回 True

>>> all([1,1,1])
True
>>> all([1,0,1])
False
>>> all([])
True

min()求最小值

any(iterable)

  如果迭代器中的任意一个值为“真”则返回 True, 否则返回 False

  注意:如果迭代器为空,返回 False

>>> any([1,0,0])
True
>>> any([0,0,0])
False
>>> any([])
False

max()求最大值

ascii(object)

  该函数返回表示对象的可打印ascii字符串,如果字符串中含有非ascii字符,则以x, u 或者 U 编码来表示

  函数其实是返回了对象的 __repr__() 方法的值

>>> a = 123
>>> a.__repr__()
'123'
>>> ascii(a)
'123'
>>> 
>>> b = 'test'
>>> b.__repr__()
"'test'"
>>> ascii(b)
"'test'"
>>>
>>> class MyTest:
...     def __repr__(self):
...         return 'Hello, world.'
... 
>>> t = MyTest()
>>> t.__repr__()
'Hello, world.'
>>> ascii(t)
'Hello, world.'

hash()获取一个对象(字符串或数值)的哈希值

bin(x)

  将整型转换为二进制的字符串,字符串以'0b' 开头.

  不过说是将整型转换为二进制,其实是将对象的__index__() 方法返回的值转换为二进制字符串

  注意: 如果对象没有__index__() 方法,将会产生异常

>>> bin(11)
'0b1011'
>>> class MyTest():
...     def __index__(self):
...         return 5
... 
>>> t = MyTest()
>>> bin(t)
'0b101'

pow(),c风格的几次方,math.pow(x, y)

 bool(x)

  如果对象为“真”则返回 True, 否则返回 False

>>> bool(0)
False
>>> bool(1)
True

sum(),对序列进行求和

 bytearray([source[, encoding[, errors]]**])

  创建一个 “可变的” byte数组,可以使用整型,字符串和迭代器来初始化

  参数为字符串时,字符串中的每一个字符将转换为数组的元素,因此需要提供编码类型,类似utf-8, ascii

  参数为整型时,整形值将作为数组的初始化大小,数组的元素则初始化为0

  参数为迭代器时,迭代器的每一个元素将作为数组的元素,因此迭代器的值必须为0-255的整型,否则将产生异常。

>>> a = bytearray(10)
>>> a
bytearray(b'x00x00x00x00x00x00x00x00x00x00')
>>> a[0]
0
>>> len(a)
10
>>> 
>>> b = bytearray('abc', 'utf-8')
>>> b
bytearray(b'abc')
>>> b[0]
97
>>> 
>>> c = bytearray(range(1,5))
>>> c
bytearray(b'x01x02x03x04')
>>> c[0]
1
>>> 
>>> d = bytearray([1,2,3])
>>> d
bytearray(b'x01x02x03')
>>> d[1] = 20
>>> d
bytearray(b'x01x14x03')

round(x[, n])返回浮点数的四舍五入,n表示小数点后预留位数,默认为0.

bytes([source[, encoding[, errors]]**])

  bytesbytearray的一个不可变的版本,其他的可以参考bytearray

>>> d = bytes([1,2,3])
>>> d
b'x01x02x03'
>>> d[1] = 20
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'bytes' object does not support item assignment

进制转换

callable(object)

  判断对象是否可以调用,如果可以则返回 True, 否则返回 False

  类是可调用的,调用后返回一个类的实例。对象如果包含了__call__()方法也是可调用的。

  其实,只要可以写成 object() 的,都是callable

>>> def foo():
...     pass
... 
>>> callable(foo)
True
>>> 
>>> class MyTest:
...     def __call__(self):
...         pass
... 
>>> callable(MyTest)
True
>>> a = MyTest()
>>> callable(a)
True
>>> 
>>> b = 1
>>> callable(b)
False

bin()返回一个整型int或long int的二进制表示

 chr(i)

  返回Unicode对应的字符。

  参数范围为 0 -- 1114111, 超过此范围将产生异常

>>> chr(97)
'a'
>>> chr(1666)
'ڂ'
>>> chr(1200000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: chr() arg not in range(0x110000)

oct()将一个整数转换成8进制字符串

classmethod(function)

  一般作为函数装饰器 @classmethod

  将类中的一个方法指定为类方法。被指定的类方法第一个参数必须为cls(方法所在的类)

  类方法的调用可以直接通过类调用,即C.f(); 也可以通过实例调用,即C().f()

  类方法有一个比较方便的用处就是作为类似C 中的初始化函数重载

class MyTest():
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day 

    @classmethod
    def from_string(cls, date_string):
        year, month, day = map(int, date_string.split('-'))
        return cls(year, month, day)

    def output(self):
        print('Birthday: {}-{}-{}'.format(self.year, self.month, self.day))



>>> a = MyTest(1989, 12, 26)
>>> a.output()
Birthday: 1989-12-26
>>> 
>>> b = MyTest.from_string('1990-1-1')
>>> b.output()
Birthday: 1990-1-1

hex() 将十进制整数转换为16进制

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

  该函数将含有python语句的字符串编译成可执行的字节码,编译的结果配合 eval, 或 exec 使用。

  source -- 需要编译的字符串

  filename -- 存储字符串的文件

  mode -- 'eval' 配合 eval 使用, 'exec' 配合多语句的 exec 使用,'single' 配合单语句的 exec 使用

  注:实测中,编译的时候会判断mode, 但是执行的时候使用 exec 或者 eval,结果一样

>>> a = compile('1 2', filename='',  mode='eval')
>>> eval(a)
3
>>> 
>>> b = compile('for i in range(3): print(i)', filename='', mode='exec')
>>> exec(b)
0
1
2
>>> 
>>> c = compile('print("Hello, world.")', filename='', mode='exec')
>>> exec(c)
Hello, world.

类型转换

complex([real[, imag]])

  返回一个复数。复数值为  real imag1j*

  参数也可以为一个表示复数的字符串,但是字符串中不能有空格。使用字符串作为参数时,没有第二个参数。***


  注1: 两个参数的缺省值均为0

  注2: 直接用复数表达式 a bj 创建的对象也是 complex 类型

>>> a = complex(1, 2)
>>> a
(1 2j)
>>> 
>>> b = 2 3j
>>> type(b)
<class 'complex'>
>>> 
>>> c = complex('5 6j')
>>> c
(5 6j)
>>> 
>>> d = complex(1 2j, 1 2j)
>>> d
(-1 3j)

int()将一个字符串或数字传换成整数,int(x, base=10)

delattr(object, name)

  删除对象的一个属性(不能是对象的方法),但是不会影响该类的其他对象。同 del object.name

  **注: 参数* name 是一个字符串


>>> class MyTest():
...     def __init__(self):
...         self.test = 'test'
... 
>>> a = MyTest()
>>> a.test
'test'
>>> b = MyTest()
>>> b.test
'test'
>>> delattr(a, 'test')
>>> a.test
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyTest' object has no attribute 'test'
>>> 
>>> b.test
'test'

float()将整数和字符串转换成浮点数

dict(*kwarg)  dict(mapping, **kwarg)  dict(iterable, **kwarg*)

  创建并返回一个字典对象。初始化参数可以有三种传入方式。

  关键字方式,将直接根据关键字生成字典

  迭代器方式,迭代器中的对象必须只有两个元素,第一个元素将作为key,第二个作为值

  映射方式,其实也是一种迭代器方式

  注: 当然也可以直接使用字典作为参数来初始化

>>> dict(one=1, two=2, three=3)
{'two': 2, 'one': 1, 'three': 3}
>>> 
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))
{'one': 1, 'two': 2, 'three': 3}
>>> 
>>> dict([('one', 1), ('two', 2), ('three', 3)])
{'one': 1, 'two': 2, 'three': 3}
>>> 
>>> dict({'one':1, 'two':2, 'three':3})
{'one': 1, 'two': 2, 'three': 3}

complex()用于创建一个复数,形如real imag*j

dir([object])

  很有用的帮助函数。显示当前命名空间,对象或者类的所有属性和方法。

  object 可以为对象或者类,如果省略表示当前的命名空间

>>> class MyTest():
...     pass
... 
>>> def foo():
...     pass
... 
>>> a = 1
>>> 
>>> dir()
['MyTest', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'foo']
>>> 
>>> import math
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
>>> 
>>> d = dict()
>>> dir(d)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

chr() 将0~255范围内的整数转换为对应的ascii字符

divmod(a, b)

  返回 (a // b, a % b) 的元组

  注:a,b可以为整型或者浮点型,但是不能是复数

>>> divmod(7, 3)
(2, 1)
>>> 
>>> divmod(4.3, 1.5)
(2.0, 1.2999999999999998)
>>> 
>>> (4.3 // 1.5, 4.3 % 1.5)
(2.0, 1.2999999999999998)

ord() 意义和chr()相反,以字符为参数,返回对应的ascii数值。

enumerate(iterable, start=0)

  返回一个可迭代的枚举类型。

  迭代器中的对象,第一个元素为序号(默认从start=0开始),第二个元素为传入迭代器中的对象。

  注: 多用于for遍历过程中,需要同时得到序号的情况。

>>> names = ['Tom', 'Jack', 'Lily']
>>> for i, name in enumerate(names, start=1):
...     print(i ,name)
... 
1 Tom
2 Jack
3 Lily

bool()将给定参数转换为布尔类型,如果没有参数,返回False。bool是int的子类。

eval(expression, globals=None, locals=None)

  将一个表示python表达式的字符串编译成python语句并执行(慎用!

  返回值,如果传入参数是字符串或者mode='eval'编译的字节码,则返回交互式运行结果,否则返回None

  globalslocals为高级用法,此处不展开。默认使用当前命名空间。

  注1: 语句必须是单条语句

  注2: 字符串中可以带入变量,但变量必须在命令空间中定义。

  注3: 可以配合compile()使用

>>> eval('2 5')
7
>>> x = 3
>>> eval('x**2   3*x   5')
23

str()将对象转化为适于阅读的形式

 exec(object, [globals[, locals]])

  将一个表示python表达式的字符串编译成python语句并执行(慎用!

  返回值为None

  globalslocals为高级用法,此处不展开。默认使用当前命名空间。

  注1: 语句可以是多条

  注2: 字符串中可以带入变量,但变量必须在命令空间中定义。

  注3: 可以配合compile()使用

>>> exec('for i in range(5): print(i)')
0
1
2
3
4

列表、元组、字典相关函数

filter(function, iterable)

  将一个可迭代的对象按传入的函数进行过滤。函数返回 True 的元素将保留,其它将被过滤掉。

>>> a = [1,2,3,4,5,6,7,8,9]
>>> list(filter(lambda x: x % 2, a))
[1, 3, 5, 7, 9]

dict() 生成字典,dict()生成空字典,dict(a='e', b='f', c='g'),传入关键字,{'a':'e', 'b':'f', 'c':'g'},dict(zip(['one', 'two', 'three'], [1, 2, 3])),dict([('one', 1), ('two', 2), ('three', 3)])

float([x])

  创建并返回一个浮点型的对象。

  x可以为一个数或者一个表示浮点数的字符串,缺省值为0

>>> float(3)
3.0
>>> float('1.23')
1.23

list()将元组转换为列表

format(value [, format_spec])

  将value按格式化转化为字符串,并返回。

  目前较多的用法是调用字符串的format方法。

  format_spec 指定格式化方式,此处不展开(将会有专题博文)。

>>> format(10, 'b')
'1010'
>>> format('555', '0>5')
'00555'

tuple()将列表转换为元组

frozenset([iterable])

  传入一个可迭代的对象,创建一个不可变的集合。除了元素不能添加删除外,其他和可变集合类似。

  如果没有参数,则创建一个空集合。

>>> a = frozenset([1,2,2,3,4,5])
>>> a
frozenset({1, 2, 3, 4, 5})
>>> 2 in a
True

all(),any()的参数都是元组或列表,区别:all()如果所有元素都不是0、''、False或者iterable为空,返回True,否则返回False;any()如果所有元素为空、0、False则返回False,如果不都为空、0、False,则返回True;all()参数是空列表或空元组,返回True,any()返回False。

getattr(object, name [, default])

  获取对象的一个属性的值。

  如果对象存在该属性则返回属性值。

  如果属性不存在,当传了default时返回default的值,否则产生异常。

  注:参数 name 是一个字符串

>>> class MyTest():
...     def __init__(self):
...         self.test = 'test'
... 
>>> a = MyTest()
>>> getattr(a, 'test')
'test'
>>> getattr(a, 'foo', 'attr not exist')
'attr not exist'
>>> 
>>> getattr(a, 'foo')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyTest' object has no attribute 'foo'

slice(stop),或slice(start, stop[, step])实现切片对象。print([1, 2, 3, 4, 5, 6, 7][slice(3)])

globals()

  返回当前全局域的{对象: 值} 字典

>>> globals()
{'__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__doc__': None, 'a': <__main__.MyTest object at 0x7f04880fb780>, '__spec__': None, 'MyTest': <class '__main__.MyTest'>}

filter()用于过滤序列,函数返回filter对象

hasattr(object, name)

  判断一个对象是否存在指定的属性。存在返回 True, 否则返回 False

  **注: 参数*name *是一个字符串***


>>> class MyTest():
...     def __init__(self):
...         self.test = 'test'
... 
>>> a = MyTest()
>>> hasattr(a, 'test')
True
>>> hasattr(a, 'foo')
False

eg。

hash(object)

  返回一个对象的hash值,如果对象不可hash会产生异常。

>>> hash(10)
10
>>> 
>>> hash('test')
2595417156033713210
>>> 
>>> hash((1,2,3))
2528502973977326415
>>> 
>>> hash([1,2,3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

def is_odd(n):

      return n % 2 == 1

aList = filter(is_odd, [1, 2, 3, 4, 5, 6, 7])

print(list(aList))

help([object])

  显示对象的帮助信息。如果没有参数则进入帮助的交互模式。

>>> help(eval)

Help on built-in function eval in module builtins:

eval(source, globals=None, locals=None, /)
    Evaluate the given source in the context of globals and locals.

    The source may be a string representing a Python expression
    or a code object as returned by compile().
    The globals must be a dictionary and locals can be any mapping,
    defaulting to the current globals and locals.
    If only globals is given, locals defaults to it.

迭代相关函数

hex(x)

  返回x的16进制字符串,字符串以'0x'开头,字符串中的字符都以小写形式表示。

  当x不是一个int型对象时,则对象必须定义一个__index__() 方法,则返回整型值,否则将产生异常。

>>> hex(64)
'0x40'
>>> hex(-10)
'-0xa'

next(iterator[,defaul]) 返回迭代器的下一个项目。

id(object)

  返回对象的内部ID值。

>>> id(123)
10923328
>>> id('test')
140589176043704
>>> id([1,2,3])
140589199591816

sorted(iterable, key=None, reverse=False),key用来进行比较的元素,指定可迭代对象的一个元素来进行排序,reverse排序规则,True为降序,False为升序。和list.sort()的区别:sorted会修改原始的list,list.sort()返回为None;另外list.sort()只为list定义,sorted函数可以接受任何iterable。eg:print(sorted({1:'A', 2:"B", 3:"C"}))

 input([prompt])

  接收标准输入转为字符串并返回。

  prompt 为输入提示字符串,可以省略。

  注:如果读到 EOF 将产生异常。

>>> s = input('Enter: ')
Enter: hello
>>> s
'hello'

iter()用于生成迭代器

 int(x=0)  int(x, base=10)

  返回一个整型数。输入参数可以是一个数或者一个字符串(当然可以是其他对象,但这里不讲解这种非主流用法)。

  参数为一个数时,返回对象的__int__()方法的值,对于整型对象就是自身的值,对于浮点型对象就是整数部分。

  参数为一个字符串时,字符串必须表示一个2、8、10、16进制,并传入相应的base值。

>>> int(3)
3
>>> int(1.25)
1
>>> int('101', 2)
5
>>> int('54', 8)
44
>>> int('123', 10)
123
>>> int('F3', 16)
243

面向对象相关函数

 isinstance(object, classinfo)

  判断对象是否属于指定的类。(可以配合 type 使用)

  注1: 如果指定类是当前对象的父类,判断结果也是 True

  **注2: 如果* classinfo 参数是一个元组,那么只要对象属于其中的一个类即返回 True


>>> a = 12
>>> b = 25
>>> isinstance(a, int)
True
>>> isinstance(a, type(b))
True
>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> a = A()
>>> b = B()
>>> isinstance(a, A)
True
>>> isinstance(b, B)
True
>>> isinstance(a, B)
False
>>> isinstance(b, A)
True
>>> isinstance(a, (A,B))
True

setattr(object, name, value),getattr(object, name)用于设置和获取属性,该属性必须存在。hasattr(object, name)用于判断属性是否存在。

issubclass(class, classinfo)

  判断一个类是否为指定类的子类。

  注1: 类都是自身的子类

  注2: 如果 classinfo 参数是一个元组,那么只要类属于其中一个类的子类即返回 True

>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> issubclass(B, A)
True
>>> issubclass(A, B)
False
>>> issubclass(A, A)
True
>>> issubclass(A, (A,B))
True

delattr(object, attr) 用于删除属性

iter(object [, sentinel])

  返回一个迭代器对象,用于遍历,一般与 next() 配合使用。

  如果 sentinel 参数没有传入则 object 必须是一个可迭代的对象。

  如果 sentinel 参数有值,则object 必须是一个 callable 的对象,此时的遍历将重复调用object, 直到返回值等于 sentinel(将产生StopIteration异常)

>>> it = iter([1,2,3])
>>> next(it)
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> 
>>> for i in iter([1,2,3]):
...     print(i)
... 
1
2
3
>>> f = open('test.txt', 'r')
>>> itf = iter(f.readline, '')
>>> next(itf)
'test line 1n'
>>> next(itf)
'test line 2n'
>>> next(itf)
'test line 3n'
>>> next(itf)
'n'
>>> next(itf)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> f.close()

hasattr(object, attr)用于判断一个对象是否有某一属性

len(s)

  返回对象的长度。对象一般是一个序列和一个集合。

  如果是其他对象,则对象必须包含 __len__() 方法,否则会产生异常。

>>> a = [1, 2, 3]
>>> len(a)
3
>>> b = 'abcdefg'
>>> len(b)
7
>>> 
>>> class MyTest:
...     def __len__(self):
...         return 5
... 
>>> c = MyTest()
>>> len(c)
5

id()用于获取对象的内存地址

list([iterable])

  创建并返回一个列表对象。如果没有传入参数,则返回一个空列表。

  传入的参数必须是一个可迭代的,迭代器中的每一个对象将作为列表的一个元素。

>>> list('abcd')
['a', 'b', 'c', 'd']
>>> list([1,2,3])
[1, 2, 3]

isinstance() 用于判断一个对象是否是某一类型,类似type,但type不会认为子类是父类类型,isinstance会认为子类是父类类型

locals()

  返回当前命名空间的{对象: 值} 字典。

>>> def foo():
...     i = 1
...     j = 2
...     k = 3
...     print(locals())
... 
>>> foo()
{'i': 1, 'k': 3, 'j': 2}

issubclass(B, A)用于判断B是否是A的子类,A、B都是类名

map(function, iterable, ...)

  返回一个迭代器。迭代器中的每一个对象将是传入的迭代器根据function的映射。

  如果超过两个参数,后面的参数适用于 function 有多个参数的情况,因此后面的迭代器的长度不能小于 iterable

>>> for i in map(lambda x: x**2, [1,2,3]):
...     print(i)
... 
1
4
9
>>> for i in map(lambda x,y: x**y, [2,2,2], [1,2,3]):
...     print(i)
... 
2
4
8

super() 用于调用父类的一个方法

max(iterable [, key, default])  max(arg1, arg2, args [, key]*)

  返回最大值。要比较的参数可以是一个可迭代的对象,也可以直接传入对象列表。

  参数 key 可以改变默认的比较方式。

  当传入的是一个迭代器时,如果迭代器为空,则返回default值,如果没有传入default将产生异常。

>>> max([3,5,1,7,9,2])
9
>>> max('aaa', 'bbb', 'ccc')
'ccc'
>>> 
>>> max([(4,2), (3,3), (2,4)], key=lambda x: x[1])
(2, 4)
>>> max([], default='empty')
'empty'

staticmethod修饰符,声明静态方法,类不需要实例化就可以调用该方法。

memoryview(obj)

  返回一个内存观察对象。传入的对象必须支持缓冲区协议,内建对象中支持的有 bytesbytearray

  内存观察对象提供一个共享的内存,可以在不需要复制的情况以不同的方式访问共享内存。在大量数据处理时比较有用。

>>> a = memoryview(b'abcdefg')
>>> a
<memory at 0x7f22addc3e88>
>>> a[0]
97
>>> a[1]
98
>>> a.tolist()
[97, 98, 99, 100, 101, 102, 103]
>>> a.tobytes()
b'abcdefg'
>>> a[1:3].tobytes()
b'bc'

classmethod修饰符,声明类方法,类方法的第一个参数是cls,和实例方法的self意义相同。如果有继承关系,子类方法调用类方法时,传递的类变量cls时子类,而非父类。

min(iterable [, key, default])  min(arg1, arg2, args [, key]*)

  返回最小值。用法与 max 类似

>>> min([3,5,1,7,9,2])
1
>>> min('aaa', 'bbb', 'ccc')
'aaa'
>>> min((4,2), (3,3), (2,4), key=lambda x: x[1])
(4, 2)
>>> min([], default='empty')
'empty'

class A:

       @classmethod

        def cm(cls):

              print('类方法调用者:', cls.__name__)

        @staticmethod

        def sm():

              print('静态方法调用')

class B(A):

       pass

A.cm()

B.cm()

A.sm()

B.sm()

next(iterator [, default])

  返回迭代器中的下一个。一般与 iter() 配合使用。

  当迭代完成以后,如果传入了default参数,则返回default的值,否则产成StopIteration异常

>>> it = iter([1,2,3])
>>> next(it)
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> 
>>> it = iter([1,2,3])
>>> next(it, default='end')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: next() takes no keyword arguments
>>> next(it, 'end')
1
>>> next(it, 'end')
2
>>> next(it, 'end')
3
>>> next(it, 'end')
'end'

其它

object()

  创建一个基本对象。该类是所有类的基类。

>>> a = object()
>>> dir(a)
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

open()用于打开一个文件,创建一个file对象

oct(x)

  返回x的8进制字符串,字符串以'0o'开头,字符串中的字符都以小写形式表示。

  当x不是一个int型对象时,则对象必须定义一个__index__() 方法,则返回整型值,否则将产生异常。

>>> oct(10)
'0o12'
>>> oct(16)
'0o20'

format()格式化函数

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

  打开一个文件,返回一个文件的对象。open的使用非常丰富,这里为扫盲,只说明最常用最基本的用法。

  参数 file, 文件名,路径可以为相对,也可以为绝对。

  参数 encoding,以何种编码方式打开文件,例如 'utf-8', 'gbk'等。

  参数 mode,打开模式

    - 'r',  只读方式,如果文件不存在将产生异常。

    - 'w',  写方式打开,如果文件存在,原文件将被覆盖,如果不存在将创建新文件。

    - 'x',创建一个新文件并打开,如果文件存在将产生异常。

    - 'a',  追加方式打开,如果文件存在,打开后指针指向文件尾部,如果不存在将创建新文件。

    - ‘b',  二进制模式打开。

    - 't',  文本模式打开(缺省)

    - ' ', 读写方式打开,配合r, w, a使用

    其中常用组合模式,r , rb , w , wb , a , ab

  注: 为保证使用安全性,常配合 with 使用

>>> f = open('test.txt', 'r', encoding='utf-8')
>>> f.readline()
'test line1n'
>>> f.close()
>>> 
>>> with open('test.txt', 'r') as f:
...     print(f.readline())
... 
test line1

zip()将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回zip对象。如果各个迭代器的元素个数不一致,则zip对象包含的列表长度与最短的对象相同,利用*号操作符,可以将元组解压为zip对象。

ord(c)

  返回字符的unicode码,该函数是chr()反向操作。

  注: 参数必须是单一的字符

>>> ord('a')
97
>>> ord(chr(99))
99
>>> chr(ord('k'))
'k'

a = [1, 2, 3]

b = ['one', 'two', 'three']

zipped = zip(a, b)

zipList = []

for it in zipped:

     print(it)

     zipList.append(it)

print(zipList)

for it in zip(*zipList):

     print(it)

pow(x, y [, z])

  求 xy 次方。结果相当于  x * y*

  如果传入了参数 z,则相当于 (x * y) % z*

  **注:*  如果 y 是负数,则不能传入 z


>>> pow(2, 3)
8
>>> pow(2, 4, 5)
1

range(stop)

print(objects, sep=' ', end='n', file=sys.stdout, flush=False*)

  打印函数。可以一次打印多个对象。sep, end, file, flush 如果需要修改,需以关键字形式指定。

  参数sep,多个对象的打印内容之间的分割符。

  参数end,所有对象内容输出完毕后输出的字符。

  参数file, 输出的地方,默认是标准输出,可以修改成文件等具有write() 方法的对象。

  参数flush, 是否立即输出。False 可能会暂时放入缓冲区。

  注: 对于自定义的对象,如果想被print调用需要具有 __str__() 方法

>>> print('hello,world')
hello,world
>>> print('hello', 'world')
hello world
>>> print('hello', 'world', sep='---')
hello---world
>>> print('hello', 'world', end='nnn')
hello world


>>> print('hello', 'world', '123', flush=True)
hello world 123
>>> 
>>> class MyTest:
...     def __str__(self):
...         return 'test'
... 
>>> a = MyTest()
>>> print(a)
test

range(start, stop[,step])

property(fget=None, fset=None, fdel=None, doc=None)

  属性装饰器。可以方便的访问对象的某个属性,避免直接操作内部属性。

  函数返回一个装饰属性,将关联 fget, fset, fdel 函数

  参数doc提供一个帮助信息。

  当用@property装饰类方法时,方法名将作为装饰属性,方法定义为只读。此时如果需要set和del需要配合@method.setter和@method.deleter使用

  注1: 两种实现方式中,get, set 和 del 都不是必须全部存在的

  注2: 两种实现方式中,get函数都只能有self参数

class MyTest:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, v): 
        self._x = v 

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "The '_x' property")



class MyTest2:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, v): 
        self._x = v 

    @x.deleter
    def x(self):
        del self._x


>>> a = MyTest()
>>> a.x
>>> 
>>> a = MyTest()
>>> print(a.x)
None
>>> a.x = 'test'
>>> print(a.x)
test
>>> del a.x
>>> print(a.x)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/taopeng/Workspace/CodeWars/tmp.py", line 7, in getx
    return self._x
AttributeError: 'MyTest' object has no attribute '_x'



>>> b = MyTest2()
>>> print(b.x)
None
>>> b.x = 3
>>> print(b.x)
3
>>> del b.x
>>> print(b.x)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/taopeng/Workspace/CodeWars/tmp.py", line 25, in x
    return self._x
AttributeError: 'MyTest2' object has no attribute '_x'

返回可迭代对象,start默认为0,step默认为1。

range(stop)  range(start, stop [, step])

  生成一个数字序列迭代器。

  当只有一个参数时,序列为0到stop(不包括stop值), 步进为1

  当有两个参数时,序列为start到stop(不包括stop值),步进为1

  三个参数时,即可自定义步进

>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(3,9))
[3, 4, 5, 6, 7, 8]
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]

repr(object)

  和 ascii() 类似,返回对象的可打印字符串。

  自定义对象如果需要 repr(),需要定义__repr__() 方法

>>> a = 123
>>> repr(a)
'123'
>>> b = 'test'
>>> repr(b)
"'test'"
>>> class MyTest:
...     def __repr__(self):
...         return 'Hello, world'
... 
>>> c = MyTest()
>>> repr(c)
'Hello, world'

reversed(seq)

  返回一个序列逆序的迭代器。

  如果是自定义对象,需要实现 __reversed__() 方法或者支持序列协议

>>> list(reversed([1,2,3,4,5]))
[5, 4, 3, 2, 1]

round(number [, ndigits])

  保留指定的小数位,返回一个最接近的数。

  参数 ndigits 默认为None, 即只保留整数部分。

  注1: 该函数当向上和向下取近似距离相同时,优先取较小的偶数。

  注2: ndigits 如果填0,虽然只保留整数位,但是会返回浮点型

>>> round(1.1)
1
>>> round(1.8)
2
>>> round(1.5)
2
>>> round(2.5)
2
>>> round(3.5)
4
>>> round(3.14, 1)
3.1
>>> round(3.16, 0)
3.0

set([iterable])

  创建一个集合对象。如果没有参数则创建一个空集合。

  参数必须是可迭代的。迭代器中的相同的对象将只会保留一个。

>>> set([1,2,3])
{1, 2, 3}
>>> set([1,1,2,2,3])
{1, 2, 3}
>>> set(range(10))
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

setattr(object, name, value)

  给对像的指定属性赋值。如果对象不存在该属性,将先创建该属性。

  注:参数 name 是一个字符串***


>>> class MyTest():
...     pass
... 
>>> a = MyTest()
>>> setattr(a, 'test', 'hello')
>>> getattr(a, 'test')
'hello'
>>> setattr(a, 'test', 'hello, world')
>>> getattr(a, 'test')
'hello, world'
>>> a.test
'hello, world'

slice(stop)  slice(start, stop [, step])

  生成一个分片对象。用于对序列进行分片。

  当只有一个参数时,序列为0到stop(不包括stop值), 步进为1

  当有两个参数时,序列为start到stop(不包括stop值),步进为1

  三个参数时,即可自定义步进

  不过一般可以直接在序列中用分片语法,例如 a为一个列表,分片语法为: a[start:stop:step]

>>> myslice = slice(1,5,1)
>>> a = [1,2,3,4,5,6,7,8,9]
>>> a[myslice]
[2, 3, 4, 5]
>>> a[1:5:1]
[2, 3, 4, 5]

sorted(iterable, , key=None, reverse=False*)

  返回一个经过排序的列表。key, reverse参数必须以关键字形式传入。

  需要排序的对象必须是可迭代的。

  参数key,排序的关键字。

  参数reverse,是否逆序,默认从小到大。

  注: 参数*可以忽略。

>>> a = [5,6,3,1,7,4,9]
>>> sorted(a)
[1, 3, 4, 5, 6, 7, 9]
>>> sorted(a, reverse=True)
[9, 7, 6, 5, 4, 3, 1]
>>> b = ['B', 'a', 'g', 'F', 'z', 'K']
>>> sorted(b)
['B', 'F', 'K', 'a', 'g', 'z']
>>> sorted(b, key=str.lower)
['a', 'B', 'F', 'g', 'K', 'z']

staticmethod(function)

  一般作为函数装饰器使用 @staticmethod 。类似 classmethod

  将类中的一个方法指定为静态方法  

  静态方法的调用可以直接通过类调用,即C.f(); 也可以通过实例调用,即C().f()

  个人感觉静态方法适合将函数归类打包

  注:静态方法是可以继承的

>>> class MyTest:
...     @staticmethod
...     def static_test():
...         print('This is a static method')
... 
>>> 
>>> a = MyTest()
>>> a.static_test()
This is a static method
>>> 
>>> MyTest.static_test()
This is a static method

str(object='')  str(object=b'', encoding='utf-8', errors='strict')

  创建并返回一个字符串对象。

  可以使用指定的对象来初始化。初始化将使用对象的 __str__() 方法返回的值。

>>> str(12345)
'12345'
>>> str('test')
'test'
>>> str([1,2,3])
'[1, 2, 3]'
>>> class MyTest:
...     def __str__(self):
...         return 'Hello'
... 
>>> a = MyTest()
>>> str(a)
'Hello'

sum(iterable [, start])

  对一个序列求和。

  参数start, 指定一个初始值,默认是0

>>> sum(range(5))
10
>>> sum(range(5), 3)
13
>>> sum({1,2,3})
6

super([type [, object-or-type]])

  返回父类的方法、对象。一般用于继承处理中,特别是初始化。

  在初始化中,super的参数可以省略。

class A:
    def __init__(self):
        print('Class A init')

class B(A):
    def __init__(self):
        super().__init__()
        print('Class B init')


class C(A):
    def __init__(self):
        super(C, self).__init__()
        print('Class C init')


>>> b = B()
Class A init
Class B init
>>> c = C()
Class A init
Class C init

tuple([iterable])

  创建并返回一个元组对象。

  可以使用一个可迭代对象初始化元组。

>>> tuple(range(5))
(0, 1, 2, 3, 4)
>>> tuple('test')
('t', 'e', 's', 't')

type(object)  type(name, bases, dict)

  两个功能。传入的参数个数不同,功能不同

  一个参数时,返回对象所属的类。

  三个参数时,动态创建一个自定义类的对象。

  当需要动态创建一个类时,

  参数name, 类名

  参数bases, 类的基类,使用一个元组传入,因此可以有多个父类。

  参数dict, 类的属性和方法字典。{属性名=属性值,方法名=函数名}, 其中“函数名”是一个已经定义的函数

  注: 直接通过字典传入的方法是一个静态方法。

>>> a = [1,2,3]
>>> type(a)
<class 'list'>
>>> 
>>> def test_func():
...     print('This is a test func.')
... 
>>> b = type('MyTest', (object, ), dict(test_attr='Hello', test_method=test_func))
>>> type(b)
<class 'type'>
>>> b.test_attr
'Hello'
>>> b.test_method()
This is a test func.

vars([object])

  返回对象新添加的属性字典。如果没有参数,返回当前命名空间更新的属性字典。

  实际上函数返回的就是对象 __dict__ 属性的值。

  注: 在初始化时添加的属性不会放入 __dict__

>>> class MyTest:
...     def __init__(self):
...         a = 1
...         b = 2
... 
>>> a = MyTest()
>>> 
>>> vars(a)
{}
>>> a.c = 3
>>> vars(a)
{'c': 3}
>>> a.__dict__
{'c': 3}
>>> 
>>> vars()
{'MyTest': <class '__main__.MyTest'>, 'a': <__main__.MyTest object at 0x7f1ca394f828>, '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__'}

zip(iterables*)

  将多个序列进行重新组合,返回一个元组列表。

  每个元组从各个序列中各提取一个值。因此元组的个数由最短的序列决定。

>>> list(zip([1,1,1], [2,2,2], [3,3,3]))
[(1, 2, 3), (1, 2, 3), (1, 2, 3)]
>>> 
>>> list(zip([1,2,3], [4,5,6], [7,8,9]))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> 
>>> list(zip([1,1,1], [2,2,2], [3,3]))
[(1, 2, 3), (1, 2, 3)]

 

本文由星彩网app下载发布于计算机编程,转载请注明出处:第十五章,python全栈开发

TAG标签: 星彩网app下载
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。