澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:内置函数,python3内置函数

2019-08-17 作者:www.8455.com   |   浏览(70)

澳门新萄京官方网站 1

内建函数built-in function

  1. abs(x) :重临x的相对化值absolute value
  2. all(iterable )
    参数:iterable -- 元组或列表。
    只要iterable的保有因素不为0、''、False可能iterable为空,all(iterable)重返True,否则重返False;
    瞩目:空元组、空驶列车表再次来到值为True,这里要极其注意。
>>>all(['a', 'b', 'c', 'd'])  # 列表list,元素都不为空或0
True
>>> all(['a', 'b', '', 'd'])   # 列表list,存在一个为空的元素
False
>>> all([0, 1,2, 3])          # 列表list,存在一个为0的元素
False   
>>> all(('a', 'b', 'c', 'd'))  # 元组tuple,元素都不为空或0
True
>>> all(('a', 'b', '', 'd'))   # 元组tuple,存在一个为空的元素
False
>>> all((0, 1,2, 3))          # 元组tuple,存在一个为0的元素
False 
>>> all([])             # 空列表
True
>>> all(())             # 空元组
True
  1. any(iterable)
    参数
    iterable -- 元组或列表。
    返回值
    倘诺都为空、0、false,则赶回false,若是不都为空、0、false,则赶回true。
>>>any(['a', 'b', 'c', 'd'])  # 列表list,元素都不为空或0
True 
>>> any(['a', 'b', '', 'd'])   # 列表list,存在一个为空的元素
True 
>>> any([0, '', False])        # 列表list,元素全为0,'',false
False 
>>> any(('a', 'b', 'c', 'd'))  # 元组tuple,元素都不为空或0
True 
>>> any(('a', 'b', '', 'd'))   # 元组tuple,存在一个为空的元素
True 
>>> any((0, '', False))        # 元组tuple,元素全为0,'',false
False  
>>> any([]) # 空列表
False 
>>> any(()) # 空元组
False
  1. bin(x):再次回到int也许long int的二进制格局
    临近的:hex() 函数用于将10进制整数转变到16进制整数。
    oct(),将十进制转变为八进制
>>>bin(10)
'0b1010'
>>> bin(20)
'0b10100'
>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
print(oct(7))#>>>>>>0o7
  1. bool():将加以参数调换为布尔类型,若无参数,再次回到 False。
>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
  1. callable(object):检查三个对象是还是不是是可调用的。
    万叁次到True,object仍旧恐怕调用失利;但只要回去False,调用对象ojbect相对不会成功。
    对此函数, 方法, lambda 函式, 类, 以及贯彻了 call 方法的类实例, 它都回来 True。
>>>callable(0)
False
>>> callable("runoob")
False 
>>> def add(a, b):
...     return a   b
... 
>>> callable(add)             # 函数返回 True
True
>>> class A:                  # 类
...     def method(self):
...             return 0
... 
>>> callable(A)               # 类返回 True
True
>>> a = A()
>>> callable(a)               # 没有实现 __call__, 返回 False
False
>>> class B:
...     def __call__(self):
...             return 0
... 
>>> callable(B)
True
>>> b = B()
>>> callable(b)               # 实现 __call__, 返回 True
True
  1. chr(i):再次来到值是现阶段整数(0-255)对应的ascii字符。
>>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97)         # 十进制
0 1 a
  1. ord():与chr(i)的功用正好相反。
  2. classmethod 修饰符对应的函数无需实例化,无需 self 参数,但首先个参数需借使意味作者类的 cls 参数,能够来调用类的习性,类的秘籍,实例化对象等。
#!/usr/bin/python
# -*- coding: UTF-8 -*- 
class A(object):
    bar = 1
    def func1(self):  
        print 'foo'  
    @classmethod
    def func2(cls):
        print 'func2'
        print cls.bar
        cls().func1()   # 调用 foo 方法 
A.func2()               # 不需要实例化

输出结果为:
func2
1
foo

  1. compile() 函数将三个字符串编写翻译为字节代码。
>>>str = "for i in range(0,10): print(i)" 
>>> c = compile(str,'','exec')   # 编译为字节代码对象 
>>> c
<code object <module> at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 * 4   5"
>>> a = compile(str,'','eval')
>>> eval(a)
17
  1. complex() 函数用于创制八个值为 real imag * j 的复数恐怕转发二个字符串或数为复数。假如第二个参数为字符串,则无需钦定第一个参数
>>>complex(1, 2)
(1   2j) 
>>> complex(1)    # 数字
(1   0j) 
>>> complex("1")  # 当做字符串处理
(1   0j) 
# 注意:这个地方在" "号两边不能有空格,也就是不能写成"1   2j",应该是"1 2j",否则会报错
>>> complex("1 2j")
(1   2j)
  1. delattr 函数用于删除属性。
    delattr(x, 'foobar') 相等于 del x.foobar。
class Coordinate:
    x = 10
    y = -5
    z = 0
point1 = Coordinate() 
print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z) 
delattr(Coordinate, 'z') 
print('--删除 z 属性后--')
print('x = ',point1.x)
print('y = ',point1.y) 
# 触发错误
print('z = ',point1.z)
  1. dict()函数用于创制一个字典。
>>>dict()                        # 创建空字典
{}
>>> dict(a='a', b='b', t='t')     # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1} 
>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
  1. divmod() 函数把除数和余数运算结果结合起来,重返八个包括商和余数的元组(a // b, a % b)。
>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(1 2j,1 0.5j)
((1 0j), 1.5j)
  1. enumerate() 函数用于将四个可遍历的数量对象(如列表、元组或字符串)组合为叁个索引系列,同时列出多少和数量下标,一般用在 for 循环个中。
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 小标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

for 循环使用 enumerate

>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, seq[i]
... 
0 one
1 two
2 three
  1. eval() 函数用来施行贰个字符串表达式,并重临表达式的值。
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2   2')
4
>>> eval("n   4")
85
  1. execfile() 函数能够用来举办二个文件。
假设文件 hello.py,内容如下:
`print('runoob');`
execfile 调用该文件
>>>execfile('hello.py')
runoob
  1. filter():过滤连串,过滤掉不符合条件的因素,再次回到由符合条件成分结合的新列表。
    该取出多个参数,第2个为函数,第二个为体系,种类的每一个成分作为参数字传送递给函数实行判,然后回来 True 或 False,最后将回来 True 的成分放到新列表中。
#!/usr/bin/python
# -*- coding: UTF-8 -*- 
def is_odd(n):
    return n % 2 == 1 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
  1. float() 函数用于将整数和字符串转变来浮点数。
>>> float(' 1.23')
1.23
>>> float('   -12345n')
-12345.0
>>> float('1e-003')
0.001
>>> float(' 1E6')
1000000.0
>>> float('-Infinity')
-inf
  1. frozenset() 重返三个结霜的集结,冻结后集合不能再增加或删除任何因素。
>>>a = frozenset(range(10))     # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob') 
>>> b
frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合
>>>
  1. format():格式化输出字符串,format(value, format_spec)实质上是调用了value的format(format_spec)方法。
    print("i am {0},age{1}".format("tom",18))#>>>>>>i am tom,age18
  2. getatt() 函数用于再次回到二个对象属性值。
    getattr(x, 'foobar') 等价于 x.foobar.
>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')        # 获取属性 bar 值
1
>>> getattr(a, 'bar2')       # 属性 bar2 不存在,触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'
  1. hasattr() 函数用于决断目的是不是带有相应的习性。
    要是目的有该属性重返 True,不然重返 False。
class Coordinate:
    x = 10
    y = -5
    z = 0
point1 = Coordinate() 
print(hasattr(point1, 'x'))  # true
print(hasattr(point1, 'y'))  # true
print(hasattr(point1, 'z'))  #true
print(hasattr(point1, 'no'))  # 没有该属性false
  1. hash() 用于获取取四个指标(字符串可能数值等)的哈希值。
hash(1)
1
hash('test')
2314058222102390712
  1. id() 函数用于获取对象的内部存款和储蓄器地址。
>>>a = 'runoob'
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608
  1. int():将字符串可能其余进制的数字转化为整形。
>>>int()               # 不传入参数时,得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12',16)        # 如果是带参数base的话,12要以字符串的形式进行输入,12 为 16进制
18
>>> int('0xa',16)  
10  
>>> int('10',8)  
8
  1. isinstance() 函数来推断二个指标是还是不是是贰个已知的项目,类似 type()。

isinstance() 与 type() 区别:
type() 不会感觉子类是一种父类类型,不思考继续关系。
isinstance() 会感到子类是一种父类类型,酌量继续关系。
固然要一口咬住不放八个门类是或不是一样推荐使用 isinstance()。

a = 2 isinstance (a,int) True isinstance (a,str) False isinstance (a,(str,int,list)) # 是元组中的三个回到 True True

type() 与 isinstance()区别:

class A:
    pass 
class B(A):
    pass
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
  1. bytes()  将贰个字符串转换到字节类型
s="apple"
v=bytes(s,encoding="utf-8")
print(v)#>>>>>>b'apple'
  1. str()  将字符类型/数值类型等转移为字符串类型
1 s=100
2 print(type(s))#>>>><class 'int'>
3 s=str(s)
4 print(type(s))#>>>><class 'str'>
  1. len():重临对象长度,参数能够是类别类型(字符串,元组或列表)或映射类型(如字典)
>>> a=[1, 2, 3, 4]
>>> len(a)
4
>>> type(a)
<class 'list'>
>>> a=(1, 2, 3, 4)
>>> type(a)
<class 'tuple'>
>>> a=['list', 'adwd', 'awde']
>>> type(a)
<class 'list'>
>>> len(a)
3
>>> a='sefijefs'
>>> len(a)
8
  1. list():元组转化列表
aTuple = (123, 'xyz', 'zara', 'abc');
aList = list(aTuple)
print ("列表元素 : ", aList)
结果:
列表元素 :  [123, 'xyz', 'zara', 'abc']
  1. tuple(): 列表转化元组。与list()类似
  2. locals() 函数会以字典类型再次回到当前岗位的万事局地变量。
>>>def runoob(arg):    # 两个局部变量:arg、z
...     z = 1
...     print locals()
... 
>>> runoob(4)
{'z': 1, 'arg': 4}      # 返回一个名字/值对的字典
  1. map():依照提供的函数对点名体系做映射。
>>>def square(x) :            # 计算平方数
...     return x ** 2
>>> map(square, [1,2,3,4,5])   # 计算列表和:1 2 3 4 5
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
# 提供了两个列表,对相同位置的列表数据进行相加
>>> map(lambda x, y: x   y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
  1. max() 方法再次来到给定参数的最大值,参数可感觉连串。
  2. min()一样的用法
  3. iter() 函数用来变化迭代器。
>>>lst = [1, 2, 3]
>>> for i in iter(lst):
...     print(i)
... 
1
2
3
  1. next():再次来到迭代器的下三个类型。
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
  1. open() 函数用于展开四个文书,创造叁个 file 对象,相关的法子才方可调用它进行读写。
    file 对象方法
    file.read([size]) size未钦赐则赶回整个文件,假若文件大小>2倍内部存款和储蓄器则至极.f.read()读到文件尾时重临""(空字串)
    file.readline() 再次回到一行
    file.readline([size]) 再次来到富含size行的列表,size 未钦命则赶回全体行
    for line in f: print line #透过迭代器访谈
    f.write("hellon") #倘使要写入字符串以外的多少,先将他转移为字符串.
    f.tell() 重临二个整数,表示近来文件指针的地点(正是到文件头的比特数).
    f.seek(偏移量,[开局地方]) 用来运动文件指针.
    偏移量:单位:比特,可正可负
    胚胎地方:0-文件头,暗中同意值;1-当前岗位;2-文书尾
    f.close() 关闭文件
>>>f = open('test.txt')
>>> f.read()
'RUNOOB1nRUNOOB2n'
  1. pow() 方法再次回到 x的y次方 的值。
    以下是 math 模块 pow() 方法的语法:
import math
math.pow( x, y )

内置的 pow() 方法
pow(x, y[, z])
函数是计算x的y次方,假设z在设有,则再对结果实行取模,其结果等效于pow(x,y) %z
瞩目:pow() 通过内置的主意直接调用,内置方法会把参数作为整型,而 math 模块则会把参数转换为 float。

import math   # 导入 math 模块
print "math.pow(100, 2) : ", math.pow(100, 2)
# 使用内置,查看输出结果区别
print "pow(100, 2) : ", pow(100, 2)
print "math.pow(100, -2) : ", math.pow(100, -2)
print "math.pow(2, 4) : ", math.pow(2, 4)
print "math.pow(3, 0) : ", math.pow(3, 0)
结果:
math.pow(100, 2) :  10000.0
pow(100, 2) :  10000
math.pow(100, -2) :  0.0001
math.pow(2, 4) :  16.0
math.pow(3, 0) :  1.0

pow(x,y) 等价于 x**y:
4**2 # 结果为16
4**2.5 # 结果为32.0
pow(x,y,z) 等价于 x**y%z:
4**2.5%3 # 结果为2.0

  1. range():函数可创制三个卡尺头列表,一般用在 for 循环中。
>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)  # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]
  1. repr() 重返一个指标的 string 格式。
>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>>repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
  1. reverse() 函数用于反向列表七月素。
aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
aList.reverse();
  1. round() 方法再次回到浮点数x的四舍五入值。round() 方法重回浮点数x的四舍五入值。
round(80.23456, 2) :  80.23
round(100.000056, 3) :  100.0
round(-100.000056, 3) :  -100.0
  1. slice() 函数达成切成片对象,主要用在切除操作函数里的参数字传送递。
>>>myslice = slice(5)    # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice]         # 截取 5 个元素
[0, 1, 2, 3, 4]
  1. sorted()  排序
    sorted() 函数对拥有可迭代的对象开始展览排序操作。

sort 与 sorted 区别:
sort 是选取在 list 上的艺术,sorted 能够对负有可迭代的指标开始展览排序操作。
list 的 sort 方法重返的是对曾经存在的列表举行操作,而内建函数 sorted 方法再次回到的是多个新的 list,实际不是在原先的底子上进展的操作。

a = [5,7,6,3,4,1,2] b = sorted(a) # 保留原列表 a [5, 7, 6, 3, 4, 1, 2] b [1, 2, 3, 4, 5, 6, 7] L=[('b',2),('a',1),('c',3),('d',4)] sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数 [('a', 1), ('b', 2), ('c', 3), ('d', 4)] sorted(L, key=lambda x:x[1]) # 利用key [('a', 1), ('b', 2), ('c', 3), ('d', 4)] students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] sorted(students, key=lambda s: s[2]) # 按年龄排序 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] sorted(students, key=lambda s: s[2], reverse=True) # 按降序 [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

  1. zip() 函数用于将可迭代的指标作为参数,将指标中对应的元素打包成一个个元组,然后重返由这么些元组组成的列表。
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反,可理解为解压,返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

python3常用内置函数:

停放函数:

一. 简介 

 python内置了一名目大多的常用函数,以便于我们选取,python意大利语官方文书档案详细表达:点击查阅, 为了便于查看,将松开函数的总结记录下来。

 

abs()

函数再次回到数字的绝对值

__author__ = "Tang"

a = -30
print(abs(a))# 30

1.abs()函数

abs函数是回去数字的相对值

主干语法:

abs(x)        x:数值表明式,能够是整数、浮点数、复数

实例:

print("abs(-10)":abs(-10)

输出结果为:abs(-10):10

澳门新萄京官方网站 2

二. 使用验证

   以下是Python3版本全部的嵌入函数:

澳门新萄京官方网站 3

  1. abs()  获取相对值

澳门新萄京官方网站 4

1 >>> abs(-10)
2 10
3 >>> abs(10)
4 10
5 >>> abs(0)
6 0
7 >>> a = -10
8 >>> a.__abs__()
9 10

澳门新萄京官方网站 5

2. all()  接受三个迭代器,假若迭代器的有所因素都为真,那么再次来到True,不然再次回到False

澳门新萄京官方网站 6

1 >>> tmp_1 = ['python',123]
2 >>> all(tmp_1)
3 True
4 >>> tmp_2 = []
5 >>> all(tmp_2)
6 True
7 >>> tmp_3 = [0]
8 >>> all(tmp_3)
9 False

澳门新萄京官方网站 7

3. any()  接受二个迭代器,如若迭代器里有三个要素为真,那么再次回到True,否则重返False

  1. ascii()  调用对象的__repr__()方法,获得该措施的归来值.

  2. bin(), 6. oct(),  7. hex()    五个函数作用为:将十进制数分别调换为2/8/16进制。

  3. bool()  测量试验一个对象是True还是False.

  4. bytes()  将三个字符串转变来字节类型

澳门新萄京官方网站 8

1 >>> s = 'python'
2 >>> x = bytes(s, encoding='utf-8')
3 >>> x
4 b'python'
5 >>> a = '王'
6 >>> s = bytes(a, encoding='utf-8')
7 >>> s
8 b'xe7x8ex8b'

澳门新萄京官方网站 9

  1. str()  将字符类型/数值类型等转移为字符串类型

    1 >>> str(b'xe7x8ex8b', encoding='utf-8') # 字节转变为字符串 2 '王' 3 >>> str(1) # 整数转变为字符串 4 '1'

11. challable()  剖断指标是或不是能够被调用,能被调用的目的正是一个callables对象,比如函数和带有__call__()的实例

澳门新萄京官方网站 10

1 >>> callable(max)
2 True
3 >>> callable([1, 2, 3])
4 False
5 >>> callable(None)
6 False
7 >>> callable('str')
8 False

澳门新萄京官方网站 11

  1. char(),13. ord()  查看十进制数对应的ASCII字符/查看有些ASCII对应的十进制数

澳门新萄京官方网站 12

 1 >>> chr(-1)
 2 Traceback (most recent call last):
 3   File "<pyshell#26>", line 1, in <module>
 4     chr(-1)
 5 ValueError: chr() arg not in range(0x110000)
 6 >>> chr(0)
 7 'x00'
 8 >>> ord('x00')
 9 0
10 >>> ord('7')
11 55

澳门新萄京官方网站 13

14. classmethod()  用来钦定三个主意为类的措施,由类直接调用实施,唯有一个cls参数,实践雷的不二秘诀时,自动将调用该方法的类赋值给cls.未有此参数钦点的类的形式为实例方法

澳门新萄京官方网站 14

 1 class Province:
 2     country = "中国"
 3       
 4     def __init__(self, name):
 5         self.name = name
 6       
 7     @classmethod
 8     def show(cls):  # 类方法,由类调用,最少要有一个参数cls,调用的时候这个参数不用传值,自动将类名赋值给cls
 9         print(cls)
10       
11 # 调用方法
12 Province.show()

澳门新萄京官方网站 15

15. complie()  将字符串编写翻译成python能辨别或能够施行的代码,也足以将文字读成字符串再编写翻译

1 compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
2 将source编译为代码或者AST对象。代码对象能过通过exec语句来执行或者eval()进行求值。
3 参数source:字符串或者AST(abstract syntax trees)对象。
4 参数filename:代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
5 参数model:指定编译代码的种类。可以指定'exec', 'eval', 'single'。
6 参数flag和dont_inherit:这两个参数为可选参数。

1 >>> s  = "print('helloworld')"
2 >>> r = compile(s, "<string>", "exec")
3 >>> r
4 <code object <module> at 0x000001C648038390, file "<string>", line 1>
  1. complex()

    1 创立二个值为real imag * j的复数可能转载一个字符串或数为复数。若是第一个参数是字符串,则无需钦点第四个参数。 2 参数real:int,long,float或字符串。 3 参数imag:int,long,float。

  2. delattr()  删除对象的质量

  3. dict()  创设数量字典

澳门新萄京官方网站 16

1 >>> a = dict()  空字典
2 >>> a
3 {}
4 >>> b = dict(one = 1, two =2)
5 >>> b
6 {'one': 1, 'two': 2}
7 >>> c = dict({'one':1 ,'two':2})
8 >>> c
9 {'one': 1, 'two': 2}

澳门新萄京官方网站 17

19. dir()  不带参数时回来当前范围内的变量,方法和定义的品种列表,带参数时回来参数的习性,方法列表

澳门新萄京官方网站 18

1 >>> dir()
2 ['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'li', 'li1', 'li2', 'li_1']
3 >>> dir(list)
4 ['__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']

澳门新萄京官方网站 19

  1. divmod()  分别取商和余数

    1 >>> divmod(20,6) 2 (3, 2)

21. enumerate()  重临三个得以枚举的指标,该对象的next()方法将赶回多个元组

澳门新萄京官方网站 20

1 >>> test = ['a', 'b', 'c']
2 >>> for k,v in enumerate(test):
3     print(k,v)
4  
5 # 输出结果:
6 0 a
7 1 b
8 2 c

澳门新萄京官方网站 21

  1. eval()  将字符串str当成有效的表明式来求值并重回总计结果

    1 >>> s = "1 2*3" 2 >>> type(s) 3 4 >>> eval(s) 5 7

  2. exec()  执行字符串或complie方法编写翻译过的字符串,没有重临值

  3. filter()  过滤器,构造多个行列,等价于[ item for item in iterables if function(item)],在函数中设定过滤条件,逐个循环迭代器中的成分,将重回值为True时的元素留下,产生三个filter类型数据

澳门新萄京官方网站 22

1 filter(function, iterable)
2 参数function:返回值为True或False的函数,可以为None。
3 参数iterable:序列或可迭代对象。
4 >>> def bigerthan5(x):
5 ...     return x > 5
6 >>> filter(bigerthan5, [3, 4, 5, 6, 7, 8])
7 [6, 7, 8]

澳门新萄京官方网站 23

  1. float()  讲多个字符串或整数转变为浮点数

澳门新萄京官方网站 24

 1 >>> float()
 2 0.0
 3 >>> float('123')
 4 123.0
 5 >>> float(1)
 6 1.0
 7 >>> float('a')
 8 Traceback (most recent call last):
 9   File "<pyshell#45>", line 1, in <module>
10     float('a')
11 ValueError: could not convert string to float: 'a'

澳门新萄京官方网站 25

  1. format()  格式化输出字符串,format(value, format_spec)实质上是调用了value的__format__(format_spec)方法

    1 >>> "I am {0}, I like {1}!".format("wang", "moon")
    2 'I am wang, I like moon!'

  2. frozenset()  创造二个不可修改的集聚

    1 frozenset([iterable]) 2 set和frozenset最实质的分别是后边三个是可变的,前面一个是不可变的。当集结对象会被更换时(举个例子删除,添港成分),只好选用set, 3 一般的话使用fronzet的地点都得以应用set。 4 参数iterable:可迭代对象。

  3. getattr()  获取对象的性格

澳门新萄京官方网站 26

 1 getattr(object, name [, defalut])
 2 获取对象object名为name的特性,如果object不包含名为name的特性,将会抛出AttributeError异常;如果不包含名为name的特性
 3 且提供default参数,将返回default。
 4 参数object:对象
 5 参数name:对象的特性名
 6 参数default:缺省返回值
 7 >>> append = getattr(list, 'append')
 8 >>> append
 9 <method 'append' of 'list' objects>
10 >>> mylist = [3, 4, 5]
11 >>> append(mylist, 6)
12 >>> mylist
13 [3, 4, 5, 6]
14 >>> method = getattr(list, 'add')
15 Traceback (most recent call last):
16   File "<stdin>", line 1, in <module>
17 AttributeError: type object 'list' has no attribute 'add'
18 >>> method = getattr(list, 'add', 'NoMethod')
19 >>> method
20 'NoMethod'

澳门新萄京官方网站 27

  1. globals()  重临一个描述当前全局变量的字典

    1 >>> a = 1 2 >>> globals() 3 {'loader': , 'a': 1, 'builtins': , 'doc': None, 'name': 'main', 'package': None, 'spec': None}

  2. hasattr()

澳门新萄京官方网站 28

1 hasattr(object,name)
2 判断对象object是否包含名为name的特性(hasattr是通过调用getattr(object,name))是否抛出异常来实现的。
3 参数object:对象
4 参数name:特性名称
5 >>> hasattr(list, 'append')
6 True
7 >>> hasattr(list, 'add')
8 False

澳门新萄京官方网站 29

  1. hash()  哈希值

    1 hash(object) 2 若是目标object为哈希表类型,重临对象object的哈希值。哈希值为整数,在字典查找中,哈希值用于快递比价字典的键。 3 四个数值假设相等,则哈希值也极度。

  2. help()  重返对象的提携文书档案

  3. id()  重回对象的内部存款和储蓄器地址

    1 >>> a = 1 2 >>> id(a) 3 1588522800

  4. input()  获取用户输入内容

    1 num = input("请输入二个数字:") 2 # 用户输入3 3 print(num) 4 # 输出结果 5 3

  5. int()  将四个字符串或数值转变为三个平日整数

澳门新萄京官方网站 30

1 int([x[,radix]])
2 如果参数是字符串,那么它可能包含符号和小数点。参数radix表示转换的基数(默认是10进制)。
3 它可以是[2,36]范围内的值,或者0。如果是0,系统将根据字符串内容来解析。
4 如果提供了参数radix,但参数x并不是一个字符串,将抛出TypeError异常;
5 否则,参数x必须是数值(普通整数,长整数,浮点数)。通过舍去小数点来转换浮点数。
6 如果超出了普通整数的表示范围,一个长整数被返回。
7 如果没有提供参数,函数返回0。

澳门新萄京官方网站 31

  1. isinstance()  检核查象是或不是是类的指标,再次回到True或False

    1 isinstance(obj, cls) 2 检查obj是不是是类cls的靶子, 重返True 或 False 3 class Foo(object): 4 pass 5 obj = Foo() 6 isinstance(obj, Foo)

  2. issubclass()  检查贰个类是或不是是另叁个类的子类。重返True或False

澳门新萄京官方网站 32

 1 issubclass(sub, super)
 2 检查sub类是否是super类的派生类(子类)。返回True 或 False
 3  
 4 class Foo(object):
 5     pass
 6    
 7 class Bar(Foo):
 8     pass
 9    
10 issubclass(Bar, Foo)

澳门新萄京官方网站 33

  1. iter()

    1 iter(o[, sentinel]) 2 再次来到四个iterator对象。该函数对于第一个参数的深入分析正视于第二个参数。 3 如果未有提供第四个参数,参数o必须是贰个会师对象,扶助遍历效率(iter()方法)或协理连串效用(getitem()方法), 4 参数为整数,从零初叶。假如不辅助那二种功能,将处分TypeError分外。 5 要是提供了第一个参数,参数o必须是七个可调用对象。在这种景色下开创贰个iterator对象,每回调用iterator的next()方法来无 6 参数的调用o,如若再次回到值等于参数sentinel,触发StopIteration分外,否则将赶回该值。

39. len()  再次来到对象长度,参数能够是种类类型(字符串,元组或列表)或映射类型(如字典)

  1. list()  列表构造函数

    1 list([iterable]) 2 list的构造函数。参数iterable是可选的,它能够是系列,援救理编辑译的容器对象,或iterator对象。 3 该函数创设贰个要素值,顺序与参数iterable一致的列表。假若参数iterable是贰个列表,将开创 4 列表的二个正片并赶回,就像是语句iterables[:]。 

  2. locals()  打字与印刷当前可用的有些变量的字典

    1 不要改换locals()重临的字典中的内容;改造只怕不会潜移默消除析器对有的变量的使用。 2 在函数体内调用locals(),重返的是随便变量。修改自由变量不会影响深入分析器对变量的利用。 3 不能够在类区域内回到自由变量。

  3. map()

澳门新萄京官方网站 34

 1 map(function, iterable,...)
 2 对于参数iterable中的每个元素都应用fuction函数,并将结果作为列表返回。
 3 如果有多个iterable参数,那么fuction函数必须接收多个参数,这些iterable中相同索引处的元素将并行的作为function函数的参数。
 4 如果一个iterable中元素的个数比其他少,那么将用None来扩展改iterable使元素个数一致。
 5 如果有多个iterable且function为None,map()将返回由元组组成的列表,每个元组包含所有iterable中对应索引处值。
 6 参数iterable必须是一个序列或任何可遍历对象,函数返回的往往是一个列表(list)。
 7  
 8 li = [1,2,3]
 9 data = map(lambda x :x*100,li)
10 print(type(data))
11 data = list(data)
12 print(data)
13  
14 运行结果:
15  
16 <class 'map'>
17 [100, 200, 300]

澳门新萄京官方网站 35

  1. max()  重返给定成分里最大值

    1 max(iterable [,args...][, key]) 2 假如只提供iterable参数,函数重返可遍历对象(如:字符串,元组或列表)中最大的非空成分。 3 要是提供五个参数,那么重回值最大的十三分参数。 4 可选参数key是单参数的排序函数。 5 假使提供key参数,必须是以命名的样式,如:max(a, b, c, key = fun)

  2. meoryview()

  3. min()  再次来到给定成分里最小值

    1 min(iterable [,args...][, key]) 2 假设只提供iterable参数,函数重回可遍历对象(如:字符串,元组或列表)中小小的的非空成分。 3 借使提供多少个参数,那么再次来到值最小的卓绝参数。 4 可选参数key是单参数的排序函数。 5 假设提供key参数,必须是以命名的样式,如:max(a, b, c, key = fun)

  4. next()  重回一个可迭代数据结构(如列表)中的下一项

  5. object()

    1 获取二个新的,无特色(geatureless)对象。Object是全部类的基类。它提供的艺术将要颇具的档案的次序实例中国共产党享。 2 该函数时2.2.本子新增加,2.3本子之后,该函数不接受其余参数。

  6. open()  张开文件

澳门新萄京官方网站 36

 1 open(filename [, mode [, bufsize]])
 2 打开一个文件,返回一个file对象。 如果文件无法打开,将处罚IOError异常。
 3 应该使用open()来代替直接使用file类型的构造函数打开文件。
 4 参数filename表示将要被打开的文件的路径字符串;
 5 参数mode表示打开的模式,最常用的模式有:'r'表示读文本,'w'表示写文本文件,'a'表示在文件中追加。
 6 Mode的默认值是'r'。
 7 当操作的是二进制文件时,只要在模式值上添加'b'。这样提高了程序的可移植性。
 8 可选参数bufsize定义了文件缓冲区的大小。0表示不缓冲;1表示行缓冲;任何其他正数表示使用该大小的缓冲区;
 9 负数表示使用系统默认缓冲区大小,对于tty设备它往往是行缓冲,而对于其他文件往往完全缓冲。如果参数值被省却。
10 使用系统默认值。

澳门新萄京官方网站 37

  1. pow()  幂函数

    1 r = pow(2, 10) # 2的10次方 2 print(r) 3
    4 # 输出 5 1024

  2. print()  输出函数

    1 python第22中学的print语句被python3中的print()函数替代。 2 如何界定print的暗许换行: 3 1. python2版本下,在print输出的末梢加一个逗号',' 4 2. python3.4随后,print(value, ...,sep='',end='n',file=sys.stdout,flush=False),将end设为空就能够。

  3. property()

52. range()  依照供给生成贰个内定范围的数字,能够提供你要求的支配来迭代钦命的次数

澳门新萄京官方网站 38

1 用于创建包含连续算术值的列表(list)。常用于for循环。参数必须是普通整数。
2 参数step默认值为1,参数start的默认值为0。
3 全参数调用该函数将返回一个普通整数列表。
4 step 可以是正整数或者负整数。不可以为0,否则将处罚ValueError异常。
5 range(3)代表0,1,2.等价于range(0,3)
6 >>> range(0,10,2)  #第一个参数是起始数,第二个是终止数(不包含这个),第三个数步数
7 >>>[0,2,4,6,8]

澳门新萄京官方网站 39

  1. repr()  将大肆值转变为字符串,供沙漏读取的款式

    1 repr(object) 2 重临三个对象的字符串表示。有的时候能够运用那一个函数来访谈操作。 3 对于多数品种来讲,repr()尝试再次回到一个字符串,eval()方法能够采用该字符串爆发对象; 4 不然用尖括号括起来的,包含类名称和任何第二中医药大学消息的字符串被重返。

  2. reversed()   反转,逆序对象

    1 reversed(seq) 2 再次来到二个逆序的iterator对象。参数seq必须是八个涵盖reversed()方法的指标或支撑种类操作(len()和getitem()) 3 该函数是2.4中新扩充的

  3. round()  四舍五入

澳门新萄京官方网站 40

1 round(x [, n])
2 对参数x的第n 1位小数进行四舍五入,返回一个小数位数为n的浮点数。
3 参数n的默认值是0。结果是一个浮点数。如round(0.5)结果为1.0
4 >>> round(4,6)
5 4
6 >>> round(5,6)
7 5

澳门新萄京官方网站 41

  1. set()

  2. setattr()  与getattr()相对应

  3. slice()  切块功用

  4. sorted()  排序

澳门新萄京官方网站 42

 1 >>> sorted([36,6,-12,9,-22])  列表排序
 2 [-22, -12, 6, 9, 36]
 3 >>> sorted([36,6,-12,9,-22],key=abs) 高阶函数,以绝对值大小排序
 4 [6, 9, -12, -22, 36]
 5 >>> sorted(['bob', 'about', 'Zoo', 'Credit'])  字符串排序,按照ASCII的大小排序
 6 ['Credit', 'Zoo', 'about', 'bob']
 7 如果需要排序的是一个元组,则需要使用参数key,也就是关键字。
 8 >>> a = [('b',2), ('a',1), ('c',0)]
 9 >>> list(sorted(a,key=lambda x:x[1]))   按照元组第二个元素排序
10 [('c', 0), ('a', 1), ('b', 2)]
11 >>> list(sorted(a,key=lambda x:x[0]))   按照元组第一个元素排序
12 [('a', 1), ('b', 2), ('c', 0)]
13 >>> sorted(['bob', 'about', 'Zoo', 'Credit'],key=str.lower) 忽略大小写排序
14 ['about', 'bob', 'Credit', 'Zoo'] 
15 >>> sorted(['bob', 'about', 'Zoo', 'Credit'],key=str.lower,reverse=True) 反向排序
16 ['Zoo', 'Credit', 'bob', 'about']

澳门新萄京官方网站 43

  1. staticmethod()

  2. str()  字符串构造函数

  3. sum()  求和

  4. super()  调用父类的方法

  5. tuple()  元组构造函数

  6. type()  显示对象所属的花色

  7. vars()  

  8. zip()  将对象逐个匹配成对

澳门新萄京官方网站 44

1 list_1 = [1,2,3]
2 list_2 = ['a','b','c']
3 s = zip(list_1,list_2)
4 print(list(s))
5  
6 运行结果:
7  
8 [(1, 'a'), (2, 'b'), (3, 'c')]

澳门新萄京官方网站 45

澳门新萄京官方网站 46

1 a = [(1,),(2,),(3,)]
2 r = zip(*a)
3 print(list(r))
4 运行结果:
5 [(1, 2, 3)]
6 print(list(r)[0])
7 运行结果:
8 (1, 2, 3)

澳门新萄京官方网站 47

 

  1. __import__()

参考: 

all()

函数用于判定给定的可迭代参数iterable中的全数因素是还是不是都为True,假若是则赶回True,不然再次来到False

一旦iterable的有着因素不为0、''"、False只怕iterable为空,all(iterable)重返True,不然再次回到False;注意 空驶列车表 空元组 空字典 空字符串是True

__author__ = "Tang"

a = all([1,0])
print(a) # False

a = all([1,False])
print(a) # False

a = all(["",1])
print(a) # False

a = all([])
print(a) # True

a = all(())
print(a) # True

a = all({})
print(a) # True

a = ""
print(all(a)) # True

1.abs():获取相对值

any() 

函数用于推断给定的可迭代参数 iterable 是不是全体为 False,则赶回 False,假使有三个为 True,则赶回 True。

若是都为空、0、false,则赶回false,假若不都为空、0、false,则赶回true

__author__ = "Tang"

a = any([1,0])
print(a) # True

a = any([1,False])
print(a) # True

a = any(["",1])
print(a) # True

a = any([])
print(a) # False

a = any(())
print(a) # False

a = any({})
print(a) # False

a=""
print(any("")) # False

2.dict()函数

dict函数用于创设三个字典

dict 语法:

classdict(** kwarg)

classdict(mapping,**kwarg)

classdict(iterable,**kwarg)

参数表达:

**kwargs -- 关键字

mapping -- 成分的器皿。

iterable -- 可迭代对象。

实例

dict()                                                    # 创造空字典{}

dict(a='a',b='b',t='t')                             # 传加入关贸总协定组织键字{'a':'a','b':'b','t':'t'}

dict(zip(['one','two','three'],[1,2,3]))     # 映射函数情势来组织字典{'three':3,'two':2,'one':1}

dict([('one',1),('two',2),('three',3)])       # 可迭代对象格局来布局字典{'three':3,'two':2,'one':1}

1 >>> abs(-10)
2 10
3 >>> a= -10
4 >>> a.__abs__()
5 10

basestring() 

措施是 str 和 unicode 的超类(父类)能够用来判定二个目的是还是不是为 str 也许unicode 的实例,isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))

 

bin()  重返多少个卡尺头 int 的二进制表示

__author__ = "Tang"

a = 10
print(bin(a)) # 0b1010

a = 500
print(bin(a)) # 0b111110100

3.help()函数

help()函数用于查看函数或模块用途的详实表达。

help 语法:

help([object])

以下实例展现了 help 的运用方法:

>>>help(sys)            # 查看 sys 模块的支援

……展现协助新闻……

>>>help(str)                # 查看 str 数据类型的扶持

……显示扶助新闻……

>>>a=[1,2,3]>>>help(a)# 查看列表 list 扶助消息

……展现支持信息……

>>>help(a.append)# 显示list的append方法的帮扶

……呈现扶助新闻……

2.all():接受三个迭代器,要是迭代器的享有因素都为真,那么再次来到True,不然再次回到False

bool() 

函数用于将加以参数转变为布尔类型,如果未有参数,再次回到 False

__author__ = "Tang"

# 为False的情况 七兄弟
# () [] {} 0 False "" 空
print(bool(())) # False
print(bool([])) # False
print(bool({}))# False
print(bool(0))# False
print(bool(False))# False
print(bool(""))# False
print(bool())# False

print(bool(10)) # 其他情况都为True

4.min()函数

min() 方法重临给定参数的微小值,参数可感觉连串。

以下是 min() 方法的语法:

min(x,y,z,....)

参数

x -- 数值表明式。

y -- 数值表明式。

z -- 数值表达式。

返回值

归来给定参数的最小值

实例

print("min(80, 100, 1000) : ",min(80,100,1000))

print("min(-20, 100, 400) : ",min(-20,100,400))

如上实例运转后输出结果为:

min(80,100,1000):80

min(-20,100,400):-20

1 >>> a = [111,'ee']
2 >>> all(a)
3 True
4 >>> all([])
5 True
6 >>> all([0])
7 False

bytearray() 

艺术重临贰个新字节数组。这一个数组里的成分是可变的,况兼各种元素的值范围: 0 <= x < 256

__author__ = "Tang"

a = bytearray()
print(a) # bytearray(b'')

a = bytearray([1,2,3]) 
print(a)#bytearray(b'x01x02x03')

5.setattr()函数

setattr函数对应函数getatt(),用于安装属性值,该属性必须存在。

语法

setattr(object,name,value)

该函数无重回值

实例

classA(object):

                      bar=1

a=A()

getattr(a,'bar')                            # 获取属性 bar 值

1

>>>setattr(a,'bar',5)                    # 设置属性 bar 值

>>>a.bar

5

3.any():接受二个迭代器,要是迭代器里有一个成分为真,那么重回True,不然重临False

callable()

 函数用于检查三个对象是或不是是可调用的。假使回到True,object仍旧只怕调用退步;但假若回去False,调用对象ojbect相对不会成功。

对此函数, 方法, lambda 函式, 类, 以及贯彻了 __call__ 方法的类实例, 它都回来 True

 

6.all函数

all() 函数用于剖断给定的可迭代参数 iterable 中的全体因素是还是不是不为 0、''、False 恐怕 iterable 为空,假设是回去 True,否则重回 False。

函数等价于:

def    all(iterable):

            for    element    in    iterable:

                        if    not    element:

                                return False

            return True

Python 2.5 以上版本可用。

以下是 all() 方法的语法:

all(iterable)

iterable能够是列表和元组

实例

all(['a','b','c','d'])# 列表list,成分都不为空或0

True

all([0,1,2,3])# 列表list,存在三个为0的因素

False

all(('a','b','c','d'))# 元组tuple,成分都不为空或0

True

all(('a','b','','d'))# 元组tuple,存在四个为空的成分

False

all([])        # 空列表

True

all(())        # 空元组        

True

4. bin(),oct(), hex()  :八个函数成效为:将十进制数分别调换为2/8/16进制。

chr()

用二个限制在 range(256)内的(就是0~255)整数作参数,重临三个应和ascii字符

__author__ = "Tang"

print(chr(97)) # a

7.dir()函数

dir()函数不带参数时,再次来到当前限定内的变量、方法和概念的门类列表;带参数时,重返参数的本性、方法列表。假若参数包涵方法__dir__(),该措施将被调用。假使参数不分包__dir__(),该办法将最大限度地搜聚参数新闻。

语法

dir([object])

以下实例呈现了 dir 的施用情势:

dir()                #  得到当前模块的性质列表['__builtins__','__doc__','__name__','__package__','arr','myslice']

1 >>> a =12
2 >>> bin(a)
3 '0b1100'
4 >>> oct(a)
5 '0o14'
6 >>> hex(a)
7 '0xc'

classmethod 

修饰符对应的函数无需实例化,不须要 self 参数,但第二个参数需假设意味本人类的 cls 参数,能够来调用类的习性,类的主意,实例化对象等

是类里面方法的语法糖,有property,staticmethod等

__author__ = "Tang"

class A(object):
    @classmethod
    def func1(self):
        print('foo')

A.func1()  # foo

8.hex()函数

hex()函数用于将10进制整数调换来16进制整数。

语法

hex(x)

参数表达:

x -- 10进制整数

以下实例体现了 hex 的应用格局:

hex(255)            结果为:    '0xff'

hex(-42)             结果为:   '-0x2a'

hex(1L)              结果为:    '0x1L'

5.bool():测量试验二个对象是True依然False
6.bytes():将三个字符串转换到字节类型

cmp(x,y)

Python3中曾经不能够使用该函数

 

9.next()函数

1 >>> a = '123'
2 >>>bytes(a,encoding = 'utf-8')
3 b'123'
4 >>> a = '胡'
5 >>> bytes(a,encoding = 'utf-b')
6 b'xe8x83xa1'

compile()

函数将二个字符串编写翻译为字节代码

__author__ = "Tang"

# compile() 函数将一个字符串编译为字节代码
# compile(*args, **kwargs)
str1 = "for i in range(1,10): print(i,end=' ')"
a = (compile(str1,"","exec"))
print(a) # <code object <module> at 0x02AFD758, file "", line 1>
exec(a) # 1 2 3 4 5 6 7 8 9

next()重回迭代器的下三个品种。

语法

next 语法:

next(iterator[,default])

参数表明:

iterator -- 可迭代对象

default -- 可选,用于安装在尚未下一个因素时回来该暗中认可值,假如不设置,又从未下二个成分则会触发 StopIteration 卓殊。

实例

澳门新萄京官方网站 48

7.str():将字符类型/数值类型等转移为字符串类型
   chr():查看十进制数对应的ASCII字符

delattr(object,name) 

函数用于删除属性

__author__ = "Tang"

class A:
    x = 20

print(A.x) # 20
delattr(A,"x")
print(A.x) #报错

   ord():查看有个别ASCII对应的十进制数

dict() 

函数用于创建八个字典 五星等第*****

__author__ = "Tang"

"""
class dict(**kwarg) # 键值对方式
class dict(mapping, **kwarg) # 映射函数方式来构造字典
class dict(iterable, **kwarg) # 可迭代对象方式来构造字典
"""

a = dict(a='a',b='b',c='c')
print(a) # {'a': 'a', 'b': 'b', 'c': 'c'}

a = dict(zip([1,2,3,4,5],['a','b','c','d','e']))
print(a) # {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e'}

a = dict([(1,'a'),(2,'b'),(3,'c'),(4,'d')])
print(a) # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}

a = dict(((1,'a'),(2,'b'),(3,'c'),(4,'d'),))
print(a) # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}

10.slice()函数

slice()函数达成切成丝对象,首要用在切除操作函数里的参数字传送递。

slice 语法:

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

参数表达:

start -- 起先地方

stop -- 截至地点

step -- 间距

实例

澳门新萄京官方网站 49

 1 >>> str(b'xe8x83xa1', encoding='utf-8')  # 字节转换为字符串
 2 '胡'
 3 >>> str(1)   # 整数转换为字符串
 4 '1'
 5 
 6 >>> chr (55)
 7 '7'
 8 >>> chr(5)
 9 'x05'
10 
11 >>> ord('7')
12 55
13 >>> ord('3')
14 51

dir() 

函数不带参数时,再次回到当前界定内的变量、方法和定义的种类列表;带参数时,重临参数的习性、方法列表。假诺参数包罗方法__dir__(),该办法将被调用。纵然参数不带有__dir__(),该方法将最大限度地征集参数音信

__author__ = "Tang"

"""此方法在学习过程中非常有用,可用于查看类的方法"""

print(dir())
"""
['__annotations__', '__author__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
"""

print(dir( [] ))
"""
查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__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']
"""

11.any()函数

any() 函数用于决断给定的可迭代参数 iterable 是或不是全部为空对象,要是都为空、0、false,则赶回 False,假使不都为空、0、false,则赶回 True。

函数等价于:

澳门新萄京官方网站 50

主干语法(参数iterable:元组或列表)

any(iterable)

实例:

澳门新萄京官方网站 51

8.compile():将字符串编写翻译成python能鉴别或能够进行的代码,也得以将文字读成字符串再编写翻译

divmod()

函数把除数和余数运算结果结合起来,再次来到八个包含商和余数的元组(a // b, a % b)

__author__ = "Tang"

print(divmod(9,3)) # (3, 0)

a,b = divmod(5,2)
print(a,b) # 2 1

# 如果有一个参数是小数,那么结果都是小数
a,b = divmod(10.0,3)
print(a,b) # 3.0 1.0

a,b = divmod(11,3.0)
print(a,b) # 3.0 2.0

12.divmod()函数

python divmod() 函数   把   除数 和   余数运算结果  结合起来,重回贰个涵盖  商  和    余数的元组(a // b, a % b)。

在 python 2.3 版本在此之前不允许管理复数。

函数语法

divmod(a, b)

参数表达:

a: 数字                 b: 数字

实例

divmod(7,2)

结果:(3,1)

divmod(8,2)

结果:(4,0)

divmod(1 2j,1 0.5j)

结果:((1 0j),1.5j)

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
将source编译为代码或者AST对象。代码对象能过通过exec语句来执行或者eval()进行求值。
参数source:字符串或者AST(abstract syntax trees)对象。
参数filename:代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
参数model:指定编译代码的种类。可以指定'exec', 'eval', 'single'。
参数flag和dont_inherit:这两个参数为可选参数。

>>> s  = "print('helloworld')"
>>> r = compile(s, "<string>", "exec")
>>> r
<code object <module> at 0x000001C648038390, file "<string>", line 1>

enumerate()

函数用于将二个可遍历的数量对象(如列表、元组或字符串)组合为二个目录体系

__author__ = "Tang"

"""
enumerate(sequence, [start=0]) 可以自定义start 开始下标
返回两个参数,第一个为下标,第二个为值
"""

a = ['tang','lao','er']
for key,value in enumerate(a,10):
    print(key,value)
"""
10 tang
11 lao
12 er
"""

13.id()函数

id()函数用于获取对象的内部存款和储蓄器地址

语法

id([object])

重临对象的内部存款和储蓄器地址

9.delattr():删除对象的属性
10.dict():创制字典

 eval()

函数用来试行一个字符串表明式,并回到表明式的值,能够说是三个总计器

__author__ = "Tang"

"""
eval(expression[, globals[, locals]])
expression 表达式
globals - 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象
locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象
"""

x = 2
print(eval('3 * x')) # 6

print(eval('2 2')) # 4

print(eval('2**10')) # 1024

实例

>>>a='runoob'

>>>id(a)

4531887632

>>>b=1

>>>id(b)

140588731085608

>>> a =dict()
>>> a
{}

execfile() 

函数能够用来实行叁个文本

python3 中尚无该函数 

 

14.sorted()函数

sorted()函数对持有可迭代的指标举行排序操作。

sort 与 sorted 区别:

sort 是利用在 list 上的方法,sorted 能够对富有可迭代的靶子进行排序操作。

list 的 sort 方法再次来到的是对已经存在的列表实行操作,而内建函数 sorted 方法重临的是一个新的 list,并非在本来的功底上进展的操作。

着力语法

sorted(iterable[,cmp[,key[,reverse]]])

参数表达:

iterable -- 可迭代对象。

cmp -- 相比的函数,那几个具备三个参数,参数的值都以从可迭代对象中抽取,此函数必须遵从的条条框框为,大于则赶回1,小于则赶回-1,等于则重返0。

key -- 首假使用来拓展相比较的成分,唯有一个参数,具体的函数的参数就是取自于可迭代对象中,钦点可迭代对象中的二个要从来进展排序。

reverse -- 排序法则,reverse = True 降序 , reverse = False 升序(暗中认可)。

11.dir():不带参数时重回当前限制内的变量,方法和概念的花色列表,带参数时回来参数的习性,方法列表

file()

python3 中从不应当函数

 

实例

澳门新萄京官方网站 52

1 >>> dir()
2 ['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'li', 'li1', 'li2', 'li_1']
3 
4 >>> dir(list)
5 ['__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']

filter() 

函数用于过滤连串,过滤掉不符合条件的成分,再次来到由符合条件成分结合的新列表

__author__ = "Tang"

"""
该函数接收两个参数,第一个为函数,第二个为序列,
序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中
filter(function, iterable)
"""

def test(n):
    return n%2
li = filter(test,[i for i in range(10)])
print(li) # <filter object at 0x00B132F0>
print(list(li)) # [1, 3, 5, 7, 9]

# 配合匿名函数
li = filter(lambda x:x%2,[i for i in range(10)])
print(li) # <filter object at 0x036232F0>
print(list(li)) # [1, 3, 5, 7, 9]

15.ascii()函数

ascii() 函数近乎 repr() 函数, 再次来到一个象征对象的字符串, 但是对于字符串中的非 ASCII 字符则再次回到经过 repr() 函数使用 x, u 或 U 编码的字符。 生成字符串类似 Python2 本子中 repr() 函数的重返值。

语法

ascii(object)

结果重临字符串。

12.divmod():重回商和余数

float() 

函数用于将整数和字符串调换到浮点数,字符串是数字在个中才行,不然会报错

__author__ = "Tang"

a = 10
print(float(a)) # 10.0

a = -234
print(float(a)) # -234.0

a = "123"
print(float(a)) # 123.0

a = "123abc"
print(float(a)) # 报错

实例

>>> ascii('runoob')

"'runoob'"

1 >>> divmod(20,6)
2 (3,2)

format()

请看 字符串格式化篇

16.enumerate()函数

enumerate() 函数用于将五个可遍历的数量对象(如列表、元组或字符串)组合为三个索引体系,同偶然候列出多少和多少下标,一般用在 for 循环在那之中。

语法

enumerate(sequence,[start=0])

参数:

sequence -- 一个种类、迭代器或任何援助迭代对象。

start -- 下标初步地点。

返回 enumerate(枚举) 对象。

13.enumerate():函数用于遍历类别中的成分以及它们的下标

frozenset()

再次来到三个冰冻的聚集,冻结后集结无法再增加或删除任何因素

__author__ = "Tang"

"""
class frozenset([iterable])
iterable 可迭代对象  能够被for循环的都是可迭代对象,也可以去重
"""

a = frozenset(range(10))
print(a) # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
print(list(a)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a = frozenset("tanglaoer") # 2个a
print(list(a)) # ['r', 'l', 'e', 'o', 'a', 't', 'g', 'n'] 一个a

li = [1,2,3]
li.append(4)
print(li) # [1, 2, 3, 4]

a.append(4) # 报错
print (a)  # 报错

实例:

澳门新萄京官方网站 53

 1 >>> for i,j in enumerate(('a','b','c')):
 2  >>> print(i,j)
 3 0 a
 4 1 b
 5 2 c
 6 
 7 >>> for i,j in enumerate([1,2,3]):
 8  print (i,j)
 9 0 1
10 1 2
11 2 3
12 
13 >>> for i,j in enumerate({'a':1,'b':2}):
14  print(i,j)
15 0 a
16 1 b
17 
18 >>> for i,j in enumerate('abc'):
19  print(i,j)
20 0 a
21 1 b
22 2 c

getattr()

函数用于重返一个对象属性值

__author__ = "Tang"

"""
getattr(object, name[, default])
object 对象
name 字符串,对象属性
default 默认返回值,如果不提供该参数,在没有对应属性时,将触发 AttributeError
"""
class A:
    b = 12
a = A()
c = getattr(A,'b')
print(c) # 12

d = getattr(A,'z')
print(d) # 报错 AttributeError: type object 'A' has no attribute 'z'

17.input()函数

python input() 相等于eval(raw_input(prompt)),用来获得调整台的输入。

raw_input() 将全体输入作为字符串对待,再次回到字符串类型。而 input() 在对待纯数字输入时有所温馨的性状,它回到所输入的数字的类型( int, float )。

注意:input() 和 raw_input() 那多少个函数均能收到 字符串 ,但 raw_input() 直接读取调节台的输入(任何项指标输入它都能够吸纳)。而对于 input() ,它仰望能够读取贰个官方的 python 表达式,即你输入字符串的时候必须利用引号将它括起来,不然它会抓住贰个SyntaxError 。

唯有对 input() 有特意供给,不然一般景况下我们都以推荐应用 raw_input() 来与用户交互。

注意:python3 里 input() 默许接收到的是 str 类型。

14.eval():将字符串str当成有效的表明式来求值并再次回到总计结果

globals() 

函数会以字典类型再次回到当前地方的凡事全局变量

__author__ = "Tang"

a = "tang"
print(globals())

"""
{   '__name__': '__main__',
    '__doc__': None,
    '__package__': None, 
    '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x009FC350>,
    '__spec__': None, 
    '__annotations__': {},
    '__builtins__': <module 'builtins' (built-in)>, 
    '__file__': 'F:/python_django/基础/内置函数.py', 
    '__cached__': None,
    '__author__': 'Tang',
    'a': 'tang'
}
"""

实例

澳门新萄京官方网站 54

1 >>> eval('1 2 3')
2 6

hasattr()

函数用于决断目的是或不是包蕴相应的特性

__author__ = "Tang"

"""
hasattr(object, name)
object 对象。
name 字符串,属性名
"""
class A:
    b = '10'
a = A()
print(hasattr(a,'b')) # True
print(hasattr(a,'z')) # False

18.oct() 函数

oct()函数将一个整数转变来8进制字符串。

语法

oct(x)     ---x:整形

实例

>>>oct(10)

'012'

>>>oct(20)

'024'

15.filter():过滤器,构造贰个行列,等价于[ item for item in iterables if function(item)],在函数中设定过滤条件,逐个循环迭代器中的成分,将再次回到值为True时的要素留下,产生一个filter类型数据

hash()

用来获取取一个对象(字符串或许数值等)的哈希值

__author__ = "Tang"

"""
hash(object)
"""
print(hash("tang")) # 278126952
print(hash(23)) # 23
print(hash(str([1,2,3]))) # 716557122
# print(hash([1,2,3])) # 报错

19.staticmethod() 函数

python staticmethod 重回函数的静态方法。

该格局不强制供给传递参数,如下宣示几个静态方法:

classC(object):

            @staticmethoddeff

             (arg1,arg2,...):...

上述实例申明了静态方法 f,类能够不用实例化就足以调用该方法 C.f(),当然也得以实例化后调用 C().f()。

函数语法

staticmethod(function)

实例:

澳门新萄京官方网站 55

1 filter(function, iterable)
2 参数function:返回值为True或False的函数,可以为None。
3 参数iterable:序列或可迭代对象。
4 
5 >>> def bigerthan(x):
6 ...     return x > 5
7 >>> filter(bigerthan, [3, 4, 5, 6, 7, 8])
8 [6, 7, 8]

help()

 函数用于查看函数或模块用途的事无巨细表明

__author__ = "Tang"

"""
help([object])
object 对象
"""
print(help("os")) # 查看os模块的详细帮助信息
# 输出内容太多了,我就不打印了

20.bin()函数

bin()回到八个大背头 int 只怕长整数 long int 的二进制表示。再次回到字符串

语法

bin(x)     ------x: int 或 long int 数字

实例

>>>bin(10)

'0b1010'

>>>bin(20)

'0b10100'

16.float():将三个字符串只怕整数转变来浮点数

hex()

函数用于将10进制整数转换到16进制,以字符串方式表示

__author__ = "Tang"

print(hex(10)) # 0xa

a = hex(17)
print(a, type(a)) # 0x11 <class 'str'>

21.eval() 函数

eval() 函数用来实行贰个字符串表明式,并赶回表明式的值。

语法

eval(expression[,globals[,locals]])

参数

expression -- 表达式。

globals -- 变量成效域,全局命名空间,如果被提供,则必须是叁个字典对象。

locals -- 变量功用域,局地命名空间,要是被提供,能够是其它映射对象。

澳门新萄京官方网站,实例

>>>x=7

>>>eval('3 * x')

21

>>>eval('pow(2,2)')

4

 1 >>> float()
 2 0.0
 3 >>> float('123')
 4 123.0
 5 >>> float(1)
 6 1.0
 7 >>> float('a')
 8 Traceback (most recent call last):
 9   File "<pyshell#45>", line 1, in <module>
10     float('a')
11 ValueError: could not convert string to float: 'a'

id()

函数用于获取对象的内部存款和储蓄器地址

__author__ = "Tang"

"""
在这里提一下,两个变量指向一个相同的不可变数据类型的数值时,它们的id是相同的,
但是元组不一样,它们id是改变的,与列表一样
"""
# int
a  = 10
print(id(a)) # 1368449952
b  = 10
print(id(b)) # 1368449952

# str 字符串是不可变数据类型
a = "tang"
print(id(a)) # 17810368

b = "tang"
print(id(b)) # 17810368

# 列表
a = [1,2,3,4]
print(id(a)) # 50262384

b = [1,2,3,4]
print(id(b)) # 50262344


a = (1,2,3,4,)
print(id(a)) # 6564096

b = (1,2,3,4,)
print(id(b)) # 6631664

22.int() 函数

int() 函数用于将三个字符串会数字转变为整型。

语法

classint(x,base=10)

参数

x -- 字符串或数字。

base -- 进制数,暗中同意十进制。

实例

>>>int()                    # 不传播参数时,获得结果0

0

>>>int(3)

3

>>>int(3.6)

3

>>>int('12',16)# 如若是带参数base的话,12要以字符串的款型开始展览输入,12 为 16进制

18

17.format():格式化输出字符串,format(value, format_spec)实质上是调用了value的__format__(format_spec)方法

input()

 函数接受多少个标准输入数据,重回为 string 类型

 

__author__ = "Tang"

a = input('请输入:')
print(a,type(a))

澳门新萄京官方网站 56

 

23.open() 函数

python open() 函数用于张开二个文书,创造一个file对象,相关的形式才得以调用它举行读写。

语法

open(name[,mode[,buffering]])

澳门新萄京官方网站 57

file 对象方法

file.read([size])size未内定则赶回整个文件,假若文件大小>2倍内部存款和储蓄器则有毛病.f.read()读到文件尾时重回""(空字串)

file.readline()归来一行

file.readline([size])回去包括size行的列表,size 未钦定则赶回全部行

for line in f: print line#由此迭代器访谈

f.write("hellon")#若果要写入字符串以外的多少,先将她转移为字符串.

f.tell()回来一个大背头,表示前段时间文件指针的岗位(便是到文件头的比特数).

f.seek(偏移量,[开场地方])用来移动文件指针.

偏移量:单位:比特,可正可负

起先地方:0-文件头,暗许值;1-当前地方;2-文书尾

f.close()闭馆文件

实例:

>>>f=open('test.txt')

>>>f.read()

'RUNOOB1nRUNOOB2n'

>>>f.close()

1 >>> "I am {0}, I like {1}!".format("hu", "moon")    
2  'I am wang, I like moon!'

int()

函数用于将三个字符串或数字转变为整型

 

__author__ = "Tang"

"""
class int(x, base=10)
x 字符串或数字
base 进制数,默认按十进制
"""
a = "123"
print(int(a))  # 123

# a = "abc123"
# print(int(a)) # 报错

a = 3.6
print(int(a))  # 3

a = '0xa'
print(int(a, base=16)) # 10

a = '10'
print(int(a,base=8)) # 8

24.str()函数

str() 函数将指标转化为适应人读书的方式。

语法:    class    str(object='')

实例

>>>s='RUNOOB'

>>>str(s)

'RUNOOB'

>>>dict= {'runoob':'runoob.com','google':'google.com'};

>>>str(dict)

"{'google': 'google.com', 'runoob': 'runoob.com'}"

18.frozenset():创设叁个不足修改的聚众

isinstance()

 函数来判别贰个对象是或不是是多少个已知的档案的次序,类似 type()

__author__ = "Tang"

"""
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。

isinstance(object, classinfo)
object 实例对象。
classinfo 可以是直接或间接类名、基本类型或者由它们组成的元组
"""

a = 10
print(isinstance(a,int)) # True


class A:
    pass

class B(A):
    pass
obj = B()
print(isinstance(obj,A)) #True
print(isinstance(obj,B)) #True

25.bool() 函数

bool()函数用于将加以参数调换为布尔类型,若无参数,重返 False。

bool 是 int 的子类。

语法:    classbool([x])

实例

>>>bool()

False

>>>bool(0)

False

>>>bool(1)

True

>>>issubclass(bool,int)        # bool 是 int 子类

True

1 frozenset([iterable])
2 set和frozenset最本质的区别是前者是可变的,后者是不可变的。当集合对象会被改变时(例如删除,添加元素),只能使用set,
3 一般来说使用fronzet的地方都可以使用set。
4 参数iterable:可迭代对象。

issubclass()

措施用于剖断参数 class 是或不是是类型参数 classinfo 的子类

__author__ = "Tang"

"""
issubclass(class, classinfo)
class 类。
classinfo 类
"""
class A:
    pass
class B(A):
    pass
print(issubclass(A,B)) # False
print(issubclass(B,A)) # True

26.exec 函数

exec 施行储存在字符串或文件中的 Python 语句,比较于 eval,exec能够实行更复杂的 Python 代码。

语法:exec(object[,globals[,locals]])

exec 再次回到值永恒为 None。

实例

澳门新萄京官方网站 58

19.getattr():获取对象的质量

iter() 

函数用来扭转迭代器

__author__ = "Tang"

"""
iter(object[, sentinel])
object 支持迭代的集合对象。
sentinel 如果传递了第二个参数,则参数 object 必须是一个可调用的对象(如,函数),
此时,iter 创建了一个迭代器对象,每次调用这个迭代器对象的__next__()方法时,都会调用 object
"""

li = [1,2,3]
for i in iter(li):
    print(i,end=" ") # 1 2 3

l = ['a','b','c','d']
def test():
    return l.pop()
it = iter(test,'z') # 无穷执行test() 直到test结果等于'z'
print(it.__next__()) # d
print(it.__next__()) # c
print(it.__next__()) # b
print(it.__next__()) # a
print(it.__next__()) # IndexError: pop from empty list

27.isinstance() 函数

isinstance() 函数来判断多少个对象是还是不是是二个已知的类型,类似 type()。

isinstance() 与 type() 区别:

type() 不会以为子类是一种父类类型,不思量继续关系。

isinstance() 会以为子类是一种父类类型,考虑继续关系。

要是要看清七个类型是还是不是一致推荐应用 isinstance()。

语法:isinstance(object,classinfo)

实例:

澳门新萄京官方网站 59

 1 getattr(object, name [, defalut])
 2 获取对象object名为name的特性,如果object不包含名为name的特性,将会抛出AttributeError异常;
 3 如果不包含名为name的特性且提供default参数,将返回default。
 4 参数object:对象
 5 参数name:对象的特性名
 6 参数default:缺省返回值
 7 >>> append = getattr(list, 'append')
 8 >>> append
 9 <method 'append' of 'list' objects>
10 >>> mylist = [3, 4, 5]
11 >>> append(mylist, 6)
12 >>> mylist
13 [3, 4, 5, 6]
14 >>> method = getattr(list, 'add')
15 Traceback (most recent call last):
16   File "<stdin>", line 1, in <module>
17 AttributeError: type object 'list' has no attribute 'add'
18 >>> method = getattr(list, 'add', 'NoMethod')
19 >>> method
20 'NoMethod'

len()

主意重临对象(字符、列表、元组等)长度或项目个数

__author__ = "Tang"

"""
len( s )
s -- 对象
"""
s = "tang"
print(len(s)) # 4

a = [1,2,3,4]
print(len(a)) # 4

28.ord() 函数

ord() 函数是 chr() 函数(对于8位的ASCII字符串)或 unichr() 函数(对于Unicode对象)的配对函数,它以三个字符(长度为1的字符串)作为参数,再次来到对应的 ASCII 数值,或然 Unicode 数值,假若所给的 Unicode 字符高出了你的 Python 定义范围,则会抓住三个 TypeError 的这一个。

语法:ord(c)

再次来到值是呼应的十进制整数

实例:

>>>ord('a')

97

>>>ord('b')

98

>>>ord('c')

99

20.hasattr():决断指标的性质是或不是科学

list() 

措施用于将指标转变为列表

__author__ = "Tang"

# 字符串转换
a = "tang"
print(list(a)) # ['t', 'a', 'n', 'g']

# a = 123
# print(list(a)) # 报错

a = (1,2,3,)
print(list(a)) # [1, 2, 3]

29.sum() 函数

sum()情势对一连串实行求和计算

语法:sum(iterable[,start])

实例

>>>sum([0,1,2])

3

>>>sum((2,3,4),1)# 元组总计总和后再加

 110

>>>sum([0,1,2,3,4],2)# 列表总结总和后再加

 212

hasattr(object,name)
判断对象object是否包含名为name的特性(hasattr是通过调用getattr(object,name))是否抛出异常来实现的。
参数object:对象
参数name:特性名称
>>> hasattr(list, 'append')
True
>>> hasattr(list, 'add')
False

locals()

 函数会以字典类型重回当前岗位的整套有的变量

对此函数, 方法, lambda 函式, 类, 以及贯彻了 __call__ 方法的类实例, 它都回去 True

__author__ = "Tang"

def test():
    a = 1
    print(locals()) # {'a': 1}
    print(globals())
    """
    {
    '__name__': '__main__', 
    '__doc__': None, 
    '__package__': None, 
    '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00E3C350>, 
    '__spec__': None, 
    '__annotations__': {}, 
    '__builtins__': <module 'builtins' (built-in)>, 
    '__file__': 'F:/python_django/基础/内置函数.py', 
    '__cached__': None, 
    '__author__': 'Tang', 
    'test': <function test at 0x002BB618>}
    """
test()

30.bytearray() 函数

bytearray()艺术再次来到三个新字节数组。这几个数组里的要素是可变的,并且每一个成分的值范围: 0 <= x < 256。

语法:classbytearray([source[,encoding[,errors]]])

参数

设若 source 为整数,则赶回二个长度为 source 的初叶化数组;

假定 source 为字符串,则依据钦命的 encoding 将字符串转换为字节体系;

要是 source 为可迭代类型,则成分必须为[0 ,255] 中的整数;

若果 source 为与 buffer 接口一致的对象,则此目的也能够被用来伊始化 bytearray。

若是未有输入任何参数,私下认可正是开头化数组为0个要素。

21.help():重回对象的援助文书档案
22.id():再次来到对象的内部存款和储蓄器地址

long()

python3 已经未有该函数

实例:

澳门新萄京官方网站 60

1 >>> a ='abc'
2 >>> id(a)
3 4117600

map() 

会依附提供的函数对点名连串做映射。

率先个参数 function 以参数类别中的每一个元素调用 function 函数,重回满含每一次 function 函数再次回到值的新列表

__author__ = "Tang"

"""
map(function, iterable, ...)
function  函数,有一个参数
iterable 一个或多个序列
"""
def test(a):
    return a**2
li = [1,2,3,4]
print(map(test,li)) # <map object at 0x017432F0>
print(list(map(test,li))) # [1, 4, 9, 16]

# 结合lambda表达式
a = map(lambda a:a**2,[i for i in range(10)])
print(list(a)) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

31.filter() 函数

filter()函数用于过滤系列,过滤掉不符合条件的要素,再次回到由符合条件成分结合的新列表。

该抽出多个参数,第一个为函数,第三个为种类,种类的各样成分作为参数字传送递给函数进行判,然后回到 True 或 False,最终将赶回 True 的因素放到新列表中。

语法:filter(function,iterable)

function -- 判别函数。

iterable -- 可迭代对象。

实例:

澳门新萄京官方网站 61

23.input():获取用户输入内容
24. int():将一个字符串或数值转变为贰个平常整数

max()

措施重临给定参数的最大值,参数可认为系列

__author__ = "Tang"

"""
max( x, y, z, .... )
"""
a = [1,2,3,4]
print(max(a)) # 4


a = (1,2,3,4)
print(max(a)) # 4

32.issubclass() 函数

issubclass()方法用于判定参数 class 是或不是是类型参数 classinfo 的子类。

语法:issubclass(class,classinfo)

class -- 类。

classinfo -- 类。

25.isinstance():检核查象是或不是是类的目的,再次回到True或False

memoryview() 

函数重临给定参数的内部存款和储蓄器查看对象(Momory view)。

所谓内部存款和储蓄器查看对象,是指对支撑缓冲区和睦的多寡实行李包裹装,在没有必要复制对象基础上同意Python代码访谈

__author__ = "Tang"

"""
memoryview(obj)
"""

v = memoryview(bytearray("tang",'utf-8'))
print(v[1]) # 97

print(v[0]) # 116
print(chr(v[0])) # t

实例:

澳门新萄京官方网站 62

26.iter():

min()

艺术再次回到给定参数的矮小值,参数可以为种类

__author__ = "Tang"

a = [1,2,3]
print(min(a)) # 1

33.pow() 函数

pow()办法重回 xy(x的y次方) 的值。

以下是 math 模块 pow() 方法的语法:

importmath

math.pow(x,y)

内置的 pow() 方法

pow(x,y[,z])

  1.iter(object)此时,object必须是集合对象,且支持迭代协议(iteration protocol)或许支持类别协议(sequence protocol),相当于实现了iter()方法大概getitem()方法

next() 

回到迭代器的下一个品类

__author__ = "Tang"

"""
next(iterator[, default])
iterator 可迭代对象
default 可选,用于设置在没有下一个元素时返回该默认值,如果不设置,又没有下一个元素则会触发 StopIteration 异常
"""
li = [1,2,3,4]
# print(next(li)) # TypeError: 'list' object is not an iterator

# 先转换为可迭代对象
li = iter(li)
print(next(li)) #  1
print(next(li)) #  2
print(next(li)) #  3
print(next(li,80)) #  4
print(next(li,90)) #  90 不然就报错

函数是总括x的y次方,倘诺z在设有,则再对结果进行取模,其结果等效于pow(x,y) %z

注意:pow() 通过内置的方法直接调用,内置方法会把参数作为整型,而 math 模块则会把参数调换为 float。

1 >>> a = [1,2,3,4]
2 >>> for i in iter(a):
3             print(i)
4 >>> 1
5         2
6         3
7         4

oct()

函数将二个整数转变来8进制字符串

__author__ = "Tang"

a = 10
t = oct(a)
print(a,t,type(t)) # 10 0o12 <class 'str'>

实例:

print("pow(100, 2) : ",pow(100,2))

pow(100,2):10000

  2.iter(object, sentinel)假如传递了第三个参数,则object必须是一个可调用的指标(如,函数)。此时,iter创立了一个迭代器对象,每一趟调用那几个迭代器对象的next()方法时,都会调用object.要是next的重回值等于sentinel,则抛出StopIteration相当,不然再次来到下八个值。

open()

函数用于展开多少个文书,成立一个 file 对象,相关的方式技巧够调用它实行读写

__author__ = "Tang"

"""
open(name[, mode[, buffering]])
name : 一个包含了你要访问的文件名称的字符串值。
mode : mode 决定了打开文件的模式:只读,写入,追加等。所有可取值见如下的完全列表。这个参数是非强制的,默认文件访问模式为只读(r)。
buffering : 如果 buffering 的值被设为 0,就不会有寄存。如果 buffering 的值取 1,访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数,表明了这就是的寄存区的缓冲大小。如果取负值,寄存区的缓冲大小则为系统默认


r    以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb    以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r     打开一个文件用于读写。文件指针将会放在文件的开头。
rb     以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w    打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
wb    以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
w     打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
wb     以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
a    打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
ab    以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
a     打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
ab     以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。
"""

"""
file 对象方法
file.read([size]) size未指定则返回整个文件,如果文件大小>2倍内存则有问题.f.read()读到文件尾时返回""(空字串)
file.readline() 返回一行
file.readlines([size]) 返回包含size行的列表,size 未指定则返回全部行
for line in f: print line #通过迭代器访问
f.write("hellon") #如果要写入字符串以外的数据,先将他转换为字符串.
f.tell() 返回一个整数,表示当前文件指针的位置(就是到文件头的比特数).
f.seek(偏移量,[起始位置]) 用来移动文件指针.
偏移量:单位:比特,可正可负
起始位置:0-文件头,默认值;1-当前位置;2-文件尾
f.close() 关闭文件
"""


# 有一个文件aa.txt
"""
tanglao
er
"""
f = open("aa.txt")
f.read() #tanglaonern

34.super() 函数

super()函数用于调用下贰个父类(超类)并回到该父类实例的主意。

super 是用来消除多种承袭难题的,间接用类名调用父类方法在应用单承接的时候没难题,可是假设使用多三番九回,会提到到搜索顺序(MRO)、重复调用(钻石承接)等样样难点。

MRO 正是类的秘诀分析顺序表, 其实也正是继续父类方法时的顺序表。

语法:super(type[, object-or-type])

参数

type -- 类。

object-or-type -- 类,一般是 self

实例:

澳门新萄京官方网站 63

结余内置函数请看python内置函数(2)。

 1 class counter:
 2     def __init__(self, _start, _end):
 3         self.start = _start
 4         self.end = _end
 5 
 6     def get_next(self):
 7         s = self.start
 8         if(self.start < self.end):
 9             self.start  = 1
10         else:
11             raise StopIteration
12 
13         return s
14 
15 
16 c = counter(1, 5)
17 iterator = iter(c.get_next, 3)
18 print(type(iterator))
19 for i in iterator:
20     print(i)
21 
22 执行结果:
23 <class 'callable_iterator'>
24 1
25 2

ord()

函数是 chr() 函数(对于8位的ASCII字符串)或 unichr() 函数(对于Unicode对象)的配成对函数,

它以多个字符(长度为1的字符串)作为参数,重返对应的 ASCII 数值,恐怕Unicode 数值,要是所给的 Unicode 字符跨越了你的 Python 定义范围,则会引发四个 TypeError 的那些

__author__ = "Tang"

print(ord('a')) # 97

27.len():再次来到对象长度,参数能够是系列类型(字符串,元组或列表)或映射类型(如字典)
28.map()

pow() 

艺术重回 xy(x的y次方) 的值

__author__ = "Tang"

print(pow(2,2)) # 4

print(pow(10,2)) # 100
 1 map(function, iterable,...)
 2 对于参数iterable中的每个元素都应用fuction函数,并将结果作为列表返回。
 3 如果有多个iterable参数,那么fuction函数必须接收多个参数,这些iterable中相同索引处的元素将并行的作为function函数的参数。
 4 如果一个iterable中元素的个数比其他少,那么将用None来扩展改iterable使元素个数一致。
 5 如果有多个iterable且function为None,map()将返回由元组组成的列表,每个元组包含所有iterable中对应索引处值。
 6 参数iterable必须是一个序列或任何可遍历对象,函数返回的往往是一个列表(list)。
 7  
 8 li = [1,2,3]
 9 data = map(lambda x :x*100,li)
10 print(type(data))
11 data = list(data)
12 print(data)
13  
14 #运行结果:
15  
16 <class 'map'>
17 [100, 200, 300]

print()

 方法用于打印输出,最广大的贰个函数

__author__ = "Tang"

"""
print(*objects, sep=' ', end='n', file=sys.stdout)
objects -- 复数,表示可以一次输出多个对象。输出多个对象时,需要用 , 分隔。
sep -- 用来间隔多个对象,默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符 n,我们可以换成其他字符串。
file -- 要写入的文件对象。
"""

a = "tanglaoer"
b = "chenlaosan"
print(a,b) # tanglaoer chenlaosan
print(a,b,sep='*') #tanglaoer*chenlaosan

a = [1,2,3,4]
for i in a:
    print(i)
"""
1
2
3
4
"""
for i in a:
    print(i,end=" ") #1 2 3 4 

29.max():重返给定成分里最大值

property() 

函数的法力是在新型类中回到属性值

__author__ = "Tang"

"""
class property([fget[, fset[, fdel[, doc]]]])
fget -- 获取属性值的函数
fset -- 设置属性值的函数
fdel -- 删除属性值函数
doc -- 属性描述信息
"""
class A:
    def test(self):
        print('tang')
a = A()
a.test() # tang   注意:这里有括号 是函数

class B:
    @property
    def test(self):
        print('laoer')
b = B()
b.test # 老二 注意:这里没有括号 是属性

     min():再次来到给定成分的最小值

range()

函数可成立贰个整数列表,一般用在 for 循环中

__author__ = "Tang"

"""
range(start, stop[, step])
start: 计数从 start 开始。默认是从 0 开始。例如range(5)等价于range(0, 5);
stop: 计数到 stop 结束,但不包括 stop。例如:range(0, 5) 是[0, 1, 2, 3, 4]没有5
step:步长,默认为1。例如:range(0, 5) 等价于 range(0, 5, 1)
"""

a = range(10)
print(a) # range(0, 10)
print(list(a)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a = range(2,10,2)
print(list(a)) # [2, 4, 6, 8]
1 >>> max(1,4,6,3,10)
2 10
3 >>> min(1,4,6,3,10)
4 1

reduce() 

函数会对参数系列六月素举行积攒。

函数将一个数目会集(链表,元组等)中的全体数据进行下列操作:用传给 reduce 中的函数 function(有八个参数)先对聚聚集的第 1、2 个要素实行操作,获得的结果再与第七个数据用 function 函数运算,最终获得二个结果

__author__ = "Tang"

"""
reduce(function, iterable[, initializer])
function -- 函数,有两个参数
iterable -- 可迭代对象
initializer -- 可选,初始参数
"""
from functools import reduce

def test(a,b):
    return  a  b
b = [1,2,3,4,5,6,7]
a = reduce(test,b)
print(a) # 28

# 配合lambda
a = reduce(lambda x,y:x y,b)
print(a) # 28

"""
顺便问一道题:用一句话打印1~100的和?
"""
print(sum(range(101))) # 5050

30.next():重返一个可迭代数据结构中的下一项
31.open():张开文件

reload() 

用于重新载入此前载入的模块 没啥用啊

__author__ = "Tang"

"""
reload(module)
module -- 模块对象
"""

import sys
from imp import reload

32.pow():幂函数

repr()

函数将对象转化为供解释器读取的情势

__author__ = "Tang"

s = "tanglaoer"
print(s) # tanglaoer
print(repr(s)) # 'tanglaoer'
>>> pow(2,3)
8
>>> pow(2,10)
1024

reverse()

函数用于反向列表兰月素

__author__ = "Tang"

"""
list.reverse() 无返回值
"""
a = [1,2,3,4]
print(a.reverse()) #None
print(a) # [4, 3, 2, 1]

33.print():输出函数
34.range():依据要求生成一个点名范围的数字,能够提供您要求的支配来迭代钦定的次数

 round()

方法再次回到浮点数x的四舍五入值

__author__ = "Tang"

a = 3.4
print(round(a)) # 3

a = 3.6
print(round(a)) # 4
1 用于创建包含连续算术值的列表(list)。常用于for循环。参数必须是普通整数。
2 参数step默认值为1,参数start的默认值为0。
3 全参数调用该函数将返回一个普通整数列表。
4 step 可以是正整数或者负整数。不可以为0,否则将处罚ValueError异常。
5 range(3)代表0,1,2.等价于range(0,3)
6 
7 >>> range(0,10,2)  #第一个参数是起始数,第二个是终止数(不包含这个),第三个数步数
8 >>>[0,2,4,6,8]

澳门新萄京官方网站:内置函数,python3内置函数。set() 

函数创立二个冬季不重复成分集,可举办关联测量检验,删除重复数据,仍是能够估测计算交集、差集、并集等

__author__ = "Tang"

"""
class set([iterable])
"""
x = set([1,2,3])
print(x) # {1, 2, 3}

x = set("tanglao") # 无重复的集合
print(x) # {'a', 'n', 't', 'g', 'o', 'l'}

35.reversed()反转,逆序对象

setattr()

函数对应函数 getatt(),用于安装属性值,该属性必须存在

__author__ = "Tang"

"""
setattr(object, name, value)
object -- 对象。
name -- 字符串,对象属性。
value -- 属性值
"""

class A:
    b = 1

a = A()
print(getattr(a,'b'))

setattr(a,'c',5)
print(a.c) # 5
1 >>> a = [1,2,3,4,5]
2 >>> b =reversed(a)
3 >>> print(list(b))
4 [5,4,3,2,1]

slice()

 函数完毕切条对象,首要用在切除操作函数里的参数字传送递

__author__ = "Tang"

"""
class slice(stop)
class slice(start, stop[, step])
start -- 起始位置
stop -- 结束位置
step -- 间距

返回值:
返回一个切片对象
"""

myslice = slice(3) # 设置截取5个元素的切片
a = [1,2,3,4,5,6]
print(a[myslice]) # [1, 2, 3]

36.round()四舍五入

sorted() 

函数对全部可迭代的靶子实行排序操作

__author__ = "Tang"

"""
sort 与 sorted 区别:
1.sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
2.list 的 sort 方法返回的是对已经存在的列表进行操作,
而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作
"""
a = [1,5,87,3,5,8,0]
print(a) # [1, 5, 87, 3, 5, 8, 0]
b = a.sort()
print(b) # None
print(a) # [0, 1, 3, 5, 5, 8, 87]

a = [1,5,87,3,5,8,0]
print(a) # [1, 5, 87, 3, 5, 8, 0]
b = sorted(a)
print(b) # [0, 1, 3, 5, 5, 8, 87]
print(a) # [1, 5, 87, 3, 5, 8, 0]

"""
也就是说 sort() 是在原有列表的基础上修改,并没有返回值,
而sorted() 返回一个排好序的列表,原列表并没有修改
"""
1 round(x [, n])
2 对参数x的第n 1位小数进行四舍五入,返回一个小数位数为n的浮点数。
3 参数n的默认值是0。结果是一个浮点数。如round(0.5)结果为0
4 >>> round(1.2347,3)
5 1.235
6 >>> round(1.6)
7 2
8 >>> round(1.2)
9 1

staticmethod()

重临函数的静态方法。该措施不强制要求传递参数

__author__ = "Tang"

"""
staticmethod(function)
"""

class C:
    @staticmethod
    def f():
        print("我是静态方法 我没有self")

    def t(self):
        print("我是标准方法 我有self")
C.f()
c = C()
c.f()

# C.t()# 报错
c = C()
c.t()
"""
类与实例都可以调用静态方法
注意:静态方法并没有参数 self 或者 cls,请与标准函数进行比较
"""

37.sorted():排序

str()

字符串函数

__author__ = "Tang"

a = 123
print(a,type(a)) # 123 <class 'int'>

a = 123
a = str(a)
print(a,type(a)) # 123 <class 'str'>
 1 >>> sorted([36,6,-12,9,-22])  #列表排序
 2 [-22, -12, 6, 9, 36]
 3 >>> sorted([36,6,-12,9,-22],key=abs) #高阶函数,以绝对值大小排序
 4 [6, 9, -12, -22, 36]
 5 >>> sorted(['bob', 'about', 'Zoo', 'Credit'])  #字符串排序,按照ASCII的大小排序
 6 ['Credit', 'Zoo', 'about', 'bob']
 7 #如果需要排序的是一个元组,则需要使用参数key,也就是关键字。
 8 >>> a = [('b',2), ('a',1), ('c',0)]
 9 >>> list(sorted(a,key=lambda x:x[1]))   #按照元组第二个元素排序
10 [('c', 0), ('a', 1), ('b', 2)]
11 >>> list(sorted(a,key=lambda x:x[0]))   #按照元组第一个元素排序
12 [('a', 1), ('b', 2), ('c', 0)]
13 >>> sorted(['bob', 'about', 'Zoo', 'Credit'],key=str.lower) #忽略大小写排序
14 ['about', 'bob', 'Credit', 'Zoo'] 
15 >>> sorted(['bob', 'about', 'Zoo', 'Credit'],key=str.lower,reverse=True) #反向排序
16 ['Zoo', 'Credit', 'bob', 'about']

sum()

 方法对文山会海举行求和总计

__author__ = "Tang"

"""
sum(iterable[, start])
iterable -- 可迭代对象,如:列表、元组、集合。
start -- 指定相加的参数,如果没有设置这个值,默认为0
"""
a = [1,2,3,4]
print(sum(a)) # 10

print(sum(a,10)) # 20

# 面试题 用一句话打印出1~100的和
print(sum(range(101))) # 5050

38.zip():zip([seql, ...])接受一密密麻麻可迭代对象作为参数,将对象中对应的因素打包成二个个tuple(元组),然后回来由那一个tuples组成的list(列表)。若传入参数的长短不等,则赶回list的长短和参数中长度最短的对象同样。

super() 

函数是用来调用父类(超类)的多个艺术。

super 是用来缓慢解决多种继承难题的,间接用类名调用父类方法在行使单承袭的时候没难题,可是只要运用多三番五回,会提到到寻找顺序(MRO)、重复调用(钻石继承)等样样难题。

MRO 就是类的措施分析顺序表, 其实也正是持续父类方法时的顺序表

__author__ = "Tang"

"""
super(type[, object-or-type])
type -- 类。
object-or-type -- 类,一般是 self
"""

class A():
    def tt(self):
        print("我是父类的tt")
        return
class B(A):
    def tt(self):
        super().tt() # 调用父类函数
        print("我是子类的tt")

b = B()
b.tt()
"""
我是父类的tt
我是子类的tt
"""
 1 >>> z1=[1,2,3]
 2 >>> z2=[4,5,6]
 3 >>> result1=zip(z1,z2)
 4 >>> result1
 5 [(1, 4), (2, 5), (3, 6)]
 6 >>> z3=[4,5,6,7]
 7 >>> result2=zip(z1,z3)
 8 >>> result2
 9 [(1, 4), (2, 5), (3, 6)]
10 
11 #zip()配合*号操作符,可以将已经zip过的列表对象解压
12 >>> zip(*result1)
13 [(1, 2, 3), (4, 5, 6)]
14 
15 (*)操作符与zip函数配合可以实现与zip相反的功能,即将合并的序列拆成多个tuple。
16 >>> x=[1,2,3],y=['a','b','c']
17 >>> zip(*zip(x,y))
18 [(1,2,3),('a','b','c')]
19 
20 #使用zip合并相邻的列表项
21 >>> a = [1, 2, 3, 4, 5, 6]
22 >>> list(zip(*([iter(a)] * 2)))
23 [(1, 2), (3, 4), (5, 6)]
24 
25 #使用zip反转字典
26 >>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
27 >>> m.items()
28 [('a', 1), ('c', 3), ('b', 2), ('d', 4)]
29 >>> list(zip(m.values(), m.keys()))
30 [(1, 'a'), (3, 'c'), (2, 'b'), (4, 'd')]
31 >>> mi = dict(zip(m.values(), m.keys()))
32 >>> mi
33 {1: 'a', 2: 'b', 3: 'c', 4: 'd'}

tuple()

函数将列表转变为元组

__author__ = "Tang"

a = [1,2,3,4]
b = tuple(a)
print(b) # (1, 2, 3, 4)

 

type()

函数纵然您独有第三个参数则赶回对象的连串,八个参数再次回到新的品类对象

__author__ = "Tang"

"""
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。

type(name, bases, dict)
name -- 类的名称。
bases -- 基类的元组。
dict -- 字典,类内定义的命名空间变量。
返回值
一个参数就返回对象类型, 
如果是三个参数,那么就返回新的类型对象
"""

print(type(1)) # <class 'int'>

print(type([1,2,3])) # <class 'list'>

# 创建一个类
x = type('X',(object,),dict(a=1))

print(x) # <class '__main__.X'>
obj = x()
print(obj.a) # 1

 

zip() 

函数用于将可迭代的靶子作为参数,将目的中对应的因素打包成二个个元组,然后回来由这一个元组组成的列表。

倘若每一种迭代器的成分个数不等同,则赶回列表长度与最短的对象同样,利用 * 号操作符,能够将元组解压为列表

在 Python 3.x 中为了收缩内存,zip() 再次回到的是三个对象。如需出示列表,需手动 list() 转变。

__author__ = "Tang"
"""
zip([iterable, ...])
iterabl -- 一个或多个迭代器;

返回值:
返回元组列表。
"""

a = [1,2,3,4,5]
b = ['a','b','c','d']
print(zip(a,b)) # <zip object at 0x00E7F6E8>
print(list(zip(a,b))) # [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

a = (1,2,3,4,5)
b = ('a','b','c','d')
print(zip(a,b)) # <zip object at 0x00E7F6E8>
print(list(zip(a,b))) # [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]



# 当只有一个参数时
a = [1,2,3,4,5]
print(list(zip(a))) # [(1,), (2,), (3,), (4,), (5,)]

#  zip 和* 结合使用 反解压
a = [1,2,3,4,5]
b = ['a','b','c','d']
tt = zip(a,b)

x,y = zip(*tt)
print(x,y)
"""
(1, 2, 3, 4) 
('a', 'b', 'c', 'd')
"""

 

__import__() 

函数用于动态加载类和函数 。

假设三个模块平日变化就足以采取 __import__() 来动态载入

__author__ = "Tang"

""""
__import__(name, globals=None, locals=None, fromlist=(), level=0)
"""

# 假如有一个a.py
__import__("a") # 这就是导入a模块 相当于 用字符串的格式导入该模块

 

 

 

 

  

 

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站:内置函数,python3内置函数

关键词: