Python3.7标准库下的内置函数使用方法

Python3.7标准库下的内置函数使用方法

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

内置函数(72个方法)

1. any([int,float,compile]) 返回一个绝对值.参数可以是整型,浮点数型和复数

>>> abs(2.123) 如果大于0,返回自己
2.123

>>> abs(-2.123) 如果小于0,返回与自己的相反数
2.123

>>> abs(3+4j) 如果是复数,返回复数的模,定义复数的形式 a+bj. 他的模是开根号(a*a+b*b)
5.0

2. all(可迭代对象) 返回bool类型.参数是可迭代对象,包括对象也行.只要里面包含一个假,那么结果就是假

>>> all([-1,2,1])
True
>>> all([-1,2,0]) 0是假
False
>>> all([-1,2,False]) False也是假 
False
判断假的有:0 False None,[],(),{}等等
注意:

>>> all([]) []是假为什么这里判断是真呢?
True
其实这里的all函数先去遍历可迭代对象.在判断对象里面的每一个元素是否为假.
如果没有元素可以迭代,那么返回真,看下面列子:

>>> all([[]])  这里[[]]把空列表当成列表的元素传进去了,判断为假.返回假
False  
看下面官方给出的解释:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

3. any(可迭代对象)刚好和all函数是卵生姐妹.这个判断只要一个为真.就为真,没有元素默认返回假

>>> any([])
False
官方的源码解释:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

4. ascii(obj) 返回一个可打印的对象字符串方式表示，如果是非ascii字符就会输出\x，\u或\U等字符来表示。

>>> ascii('z') 如果是ASCII值.返回本身且上 : '本身'
"'z'" 

注意 返回的不是字符串z,而是'z' 长度是3
>>> len(ascii(1))
1
>>> len(ascii('z'))
3

>>> ascii('在') 非ASCII码,返回\x，\u或\U等字符来表示
"'\\u5728'"

注:判断一个值是否是ASCII值,程序如下:
>>> s=lambda x : ascii(x)==f"'{x}'" 还有一种写法:s=lambda x : ascii(x)==repr(x),还有一种更简单s=lambda x:x.isascii()
>>> s('a')
True
>>> s('在')
False

ASCII值如何解析成中文
>>> s=ascii('作者')
>>> s
"'\\u4f5c\\u8005'"
>>> s=s[1:-1]
>>> s
'\\u4f5c\\u8005'
>>> s.encode('utf-8').decode('unicode_escape')
'作者'

5. bin([int,obj])参数是整数,返回对应的二进制.如果参数是对象.则必须要实现__index__函数

>>> bin(4) 参数是整形.直接返回二进制
'0b100'

>>> class test_bin():
        def __init__(self,x):
            self.x=x
            
        def __index__(self): bin()直接调用该方法,必须实现
            return self.x
            
>>> b=test_bin(3)

>>> bin(b) 参数是一个对象,调用对象的__index__函数
'0b11'

注:实际上实现__index__可以做一个比较6的特效
>>> ls=[1,2,3,4,5,6]
>>> b0=test_bin(3)
>>> b1=test_bin(5)
>>> ls[b0] 可以作为索引
4
>>> ls[b0:b1] 可以作为切片
[4, 5]

其实实现打印二进制的还有更灵活的方法:
>>> format(4,'#b') 利用format可以转为2,8,10,16进制,加#就是打印进制标识符.不加#则不加
'0b100'
>>> format(4,'b') 将十进制转为为二进制
'100'
>>> format(44,'#x') 十进制->十六进制
'0x2c'
>>> format(44,'#o') 十进制->八进制
'0o54'

>>> format(0x22,'#d') 十六进制->十进制
'34'

还有一种更是6的一批的方法.叫F-string,只从Python3.6之后正式加入标准库内,所以你可以大胆的使用,官方许可!
大写的F和小写的f是一样.不区分大小写
>>> f'{4:#b}' 和上面的使用方法一样.在这里就不多说了
'0b100'

>>> F'{4:b}' 一样和上面
'100'

下面是f-string的另一种用法,实际上他是format的简写
>>> name='你好'
>>> f'{name}世界'
'你好世界'

>>> '{t}世界'.format(t=name)
'你好世界'

>>> f'{2*32}' 实际上我们可以看得出.{}你们是一个可执行体
'64'

>>> f'{(lambda x : x+1)(2)}' 虽然f-string可以执行lambda表达式.但是不推荐这种做法.减少了可读性
'3'

6. bool(x=None) 返回一个布尔值，即一个True或False

>>> bool() 这个没有好说的.如果没有值.则默认是None.返回假
False

注:0, 0.0, 0j, Decimal(0), Fraction(0, 1) None and False '', (), [], {}, set(), range(0) 都是假

bool()输入的是一个对象的时候,无论对象是否实现,怎么实现.返回值都是真
>>> class A:
        pass

>>> bool(A) 传的对象对象
True
>>> bool(A()) 传的对象类
True

7. bytearray([ source [，encoding [，errors ] ]]) 返回值为一个新的字节数组,当个参数都不传的时候，返回长度为0的字节数组

第一种:三个参数都不填写,则返回空字节数组
    >>> bytearray()
    bytearray(b'')
    >>> len(bytearray())
    0

第二种:如果source参数填写的是字符串.那么encoding必须填写.
    >>> bytearray(source='作者',encoding='utf-8')
    bytearray(b'\xe4\xbd\x9c\xe8\x80\x85')
    >>> bytearray(source='作者',encoding='GBK')
    bytearray(b'\xd7\xf7\xd5\xdf')

第三种:如果source参数填写的是整数
    第三种的第一种写法:
        >>> bytearray(source=10) source必须是大于0的.意思是生成整数所指定长度的空字节数组
        bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00') 
    
    第三种的第二种写法:
        >>> bytearray([1,2,3,4]) 当source参数是一个可迭代对象，那么这个迭代对象的元素都必须符合0 <= x < 256
        bytearray(b'\x01\x02\x03\x04')
    
第四种:如果source参数是object.那么要实现buffer接口,使用只读方式将字节读取到字节数组后返回
    >>> s='作者'.encode('utf-8')
    >>> type(s)
    
     
    bytes类型实现了buffer接口
    >>> bytearray(source=s)
    bytearray(b'\xe4\xbd\x9c\xe8\x80\x85')
    
注:bytearray()返回的对象是可修改的,下面将bytes返回来的是不可以修改的
>>> b=bytearray(10)
>>> b[1]
0
>>> b[1]=1 可修改
>>> b[1]
1

8. bytes([ source [，encoding [，errors ] ] ] ) 使用方法和bytearray()一致,不同的一点是bytes返回的对象不可修改

注: bytes和str类型的区别
bytes是byte的序列，而str是unicode的序列。
str 使用encode方法转化为 bytes
bytes通过decode转化为str

bytes和bytearray的区别
bytearray是可变的。bytes是不可变的.

9. callable(obj)方法用来检测对象是否可被调用，返回真和假

第一种情况:对象能否使用()括号的方法调用
>>> callable(bool)
True
>>> callable(1)
False

第二种情况: 自定义的类,类对象一定可以被调用
>>> class test_callable():
pass

>>> callable(test_callable) 类对象
True

>>> callable(test_callable()) 类实例是否能被调用,取决于是否实现了__call__函数
False

第三种情况:类实例调用.实现__call__函数

>>> class test_callable:
        def __call__(self): 实现了__call__函数
	        pass

>>> callable(test_callable())
True
    
注:实际上callable()无论传什么进去.他都相当于在执行一次实例:t=test_callable() --> t()
记住Python一切皆是对象
>>> t=test_callable()
>>> t() 正确.没有报错误
>>> test_callable()() 正确,没有报错误

10. chr(int)参数是一个整数,范围在[0,1114111],（基于16进制的0x10FFFF）返回表示Unicode代码的字符

>>> chr(1)
'\x01'

>>> chr(97)
'a'

>>> chr(1114111)
'\U0010ffff'

>>> chr(1114112) 如果超出1114111之后报ValueError
Traceback (most recent call last):
  File "", line 1, in 
    chr(1114112)
ValueError: chr() arg not in range(0x110000)

11. @classmethod 该方法是装饰器,修改普通方法为类方法.第一个参数必须有.代表类

>>> class test_classmethod:
    test=1
    @classmethod
    def method(cls):
        return cls.test

>>> test_classmethod.method() 不要以为这个和Java的静态方法一致
1

12. compile(source,filename,mode,flags=0,dont_inherit=False,optimize=-1) 是将一个字符串编译为字节代码。

1. source -- 字符串或者AST对象。。
2. filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
3. mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
4. flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
5. flags和dont_inherit是用来控制编译源码时的标志  

第一种:编译为字节对象 返回值为None
>>> s='[print(x) for x in range(5)]'
>>> c=compile(s,'','exec') 编译为字节对象
>>> exec(c)
0
1
2
3
4

第二种:
>>> s='3+5'
>>> c=compile(s,'','exec')
>>> print(exec(c)) 返回None
None
>>> c=compile(s,'','eval') 提供返回值
>>> eval(c)
8

13. complex(([real[, imag]])) 复数函数.第一个参数的实数,第二个参数是虚数.返回的是复数形式:a+bj

>>> complex() 不写参数默认是0
0j

>>> complex(1,2)
(1+2j)

>>> complex(1)
(1+0j)

>>> complex('1+2j') 注意:1+2j之间不能有空格
(1+2j)

>>> complex('1 + 2j') 1+2j之间有空格.报ValueError错误
Traceback (most recent call last):
  File "", line 1, in 
    complex('1 + 2j')
ValueError: complex() arg is a malformed string

关于两个复数的四则运算
>>> a=complex(1+2j)
>>> b=complex(2+3j)
>>> a-b
(-1-1j)
>>> a+b
(3+5j)
>>> a*b
(-4+7j)
>>> a/b
(0.6153846153846154+0.07692307692307691j)

复数的3个内置方法
>>> a.imag 虚根
2.0
>>> a.real 实根
1.0
>>> a.conjugate() 共轭复数
(1-2j)

14. delattr(obj,name) 用于删除属性,obj是对象.name是对象的属性

 >>> class A:
        s=1

>>> a=A()
>>> a.s 能正常调用
1
>>> delattr(A,'s') 删除类对象中的s属性
>>> a.s 在调用s属性报错AttributeError
Traceback (most recent call last):
  File "", line 1, in 
    a.s
AttributeError: 'A' object has no attribute 's'

注:他的效果和del一样的
>>> del A.s

delattr函数删除的是类对象里面的属性.而并不是实例化对象里面的属性.所以就算在实例化其他对象.该对象里面仍然没有删除后的属性
实际上实例化对象是;类对象的复制品,因为是直接删除了类对象,所以就算在实例化其他,依然没有.

15. dict(** kwarg) 这个叫字典,也叫键值对.是Python里面非常重要的函数,实际上是其他语言的键值对

 第一种生成字典的方式:
 >>> dict(name='tyoui',age=25)
{'name': 'tyoui', 'age': 25}

第二种生成字典的方式:
>>> d={'name': 'tyoui', 'age': 25}
>>> d
{'name': 'tyoui', 'age': 25}

得到字典的值
 >>> d['name']
'tyoui'
>>> d.get('name')
'tyoui'

可以设置get()的参数.如果没有找到值,则返回第二个参数自己定义的值
>>> d.get('name1','没有找到值')
'没有找到值'

可以抛出一个值,不建议在循环抛出
>>> d.pop('age') 实际上pop方法我们会写两个参数.如果存在键,抛出成功后会返回值.没有键或者没有成功,则抛出异常
25
>>> d.pop('age1','没有找到该键')第二个参数和get方法一样
'没有找到该键'
>>> d
{'name': 'tyoui'}

获取键值对列表
>>> d.items()
dict_items([('name', 'tyoui')])

获取键列表
>>> d.keys()
dict_keys(['name'])

获取值列表
>>> d.values()
dict_values(['tyoui'])

创建新字典,序列seq中元素做字典的键，value为字典所有键,fromkeys(seq,[value])
>>> d.fromkeys(['a','b','c']) 只是创建一个新的字典.并没有改变以前的值
{'a': None, 'b': None, 'c': None} 实际上他没有增加以前的键值,只是单纯的用seq作为键
>>> d
{'name': 'tyoui'}

>>> d.fromkeys(['a','b','c'],10)
{'a': 10, 'b': 10, 'c': 10}

清除字典
>>> d
{'name': 'tyoui'}
>>> d.clear() 清除
>>> d
{}

修改值
>>> s
{'a': None, 'b': None, 'c': None}
>>> s['a']=1
>>> s
{'a': 1, 'b': None, 'c': None}

将一个字典的键值对加入到另一个字典上
>>> d= {'name':'jtyoui'}
>>> s
{'a': 1, 'b': None, 'c': None}
>>> s.update(d)
>>> s
{'a': 1, 'b': None, 'c': None, 'name': 'jtyoui'}

随机的抛出一对键值对
>>> s.popitem()
('name', 'jtyoui')
>>> s
{'a': 1, 'b': None, 'c': None}

该setdefault方法有点类似get方法,不过这个方法如果有键.则返回值.没有键则增加键并且设置默认值
>>> d
{'name': 'jtyoui'}
>>> d.setdefault('age') 实际上第二个参数就是设置的值.如果没有默认是None
>>> d
{'name': 'jtyoui', 'age': None}

如果增加成功.则返回添加成功的值
>>> d
{'name': 'jtyoui'}
>>> d.setdefault('age',21) 返回21
21
>>> d
{'name': 'jtyoui', 'age': 21}

如果判断字典是否包含某个键
>>> d
{'name': 'jtyoui', 'age': 21}
>>> d.__contains__('age') 在Python2.x类似于has_key()方法
True

关于字典的复制问题,内置的是浅复制,这个重点说一下
浅复制实际上是复制了第一层的引用.并非全部拷贝
>>> q={'name':'jtyoui','age':[1,2,3]}
>>> q
{'name': 'jtyoui', 'age': [1, 2, 3]}
>>> s=q.copy()
>>> s
{'name': 'jtyoui', 'age': [1, 2, 3]}
开始增加属性
>>> s['sex']='boy' 实际上在第一层增加.并不会影响另一个字典
>>> s
{'name': 'jtyoui', 'age': [1, 2, 3], 'sex': 'boy'}
>>> q 还是原来的值
{'name': 'jtyoui', 'age': [1, 2, 3]}

修改两个字典引用了同一个列表
>>> s['age'].append(4) 在列表中增加值
>>> s
{'name': 'jtyoui', 'age': [1, 2, 3, 4], 'sex': 'boy'}
>>> q 居然他也发生变化了
{'name': 'jtyoui', 'age': [1, 2, 3, 4]}

注:关于深拷贝,需要导入copy模块.使用deepcopy方法
>>> import copy
>>> t=copy.deepcopy(q) 现在这两个字典,没有一点关系了,是实实在在的拷贝.不会影响到另一个
>>> t
{'name': 'jtyoui', 'age': [1, 2, 3, 4]}

下面举两个例子:
将两个列表合并成字典
>>> ls1=['a','b']
>>> ls2=[1,2]
>>> dict(zip(ls1,ls2))
{'a': 1, 'b': 2}

将嵌套列表中的可迭代对象转为字典
>>> ls=[('a',1),('c',2)]
>>> dict(ls)
{'a': 1, 'c': 2}

16. dir([obj]) 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用

>>> dir() 当前范围内的属性
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
>>> 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']
 
 自定义一个类
 >>> class test_dir:
        s=1
        def test(self):
            pass
 >>> dir(test_dir)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
 '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
  '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
   '__weakref__', 's', 'test']   -->'s', 'test'属性
   
   自定义类中包括__dir__属性
   >>> class test_dir:
            s=1
            def test(self):
                pass
            def __dir__(self):
                return ['自定义属性']
   >>> dir(test_dir()) 这里要传的是一个对象
    ['自定义属性']

17. divmod(a,b) 返回一个包含商和余数的元组(a // b, a % b)

>>> divmod(3,4)
(0, 3)

>>> divmod(-5,-6)
(0, -5)

>>> divmod(43.33,5.3)
(8.0, 0.9299999999999997)

>>> divmod(1+2j,3+4j) 不支持复数形式
Traceback (most recent call last):
  File "", line 1, in 
    divmod(1+2j,3+4j)
TypeError: can't take floor or mod of complex number.

注:实际上如果要计算复数形式;可以这样做,关于复数更多的知识请看 内置函数13 complex 和cmath模块
>>> (1+2j)/(2+1j)
(0.8+0.6j)

18. enumerate(iterable,start=0) 函数用于将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下标,start是下标的起始值

>>> ls=map(lambda x :chr(x),range(65,70)) 映射ASCII值
>>> list(enumerate(ls)) 遍历创建索引,默认是下标0开始
[(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'), (4, 'E')]
>>> list(enumerate(ls,start=65))下标为65开始
[(65, 'A'), (66, 'B'), (67, 'C'), (68, 'D'), (69, 'E')]

实现上用处最多的地方还是下面这种
>>> seq=['a','b','c'] 
>>> for i,v in enumerate(seq):
        print(i,v)

0 a
1 b
2 c
 
关于Python非常彪悍的生成器,会有一大篇文章来讲述 yield

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

19. eval(expression,[globals=None,locals=None]) 函数用来执行一个字符串表达式，并返回表达式的值

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


>>> eval('3+4')
7

>>> eval('abs(-123)')
123

>>> a=1
>>> eval('a+2') 实际上他把a当成变量
3

我们来试一下什么是变量作用域
>>> x,y=1,2
>>> eval('x+y')
3

>>> def test_eval():
        x,y=3,3 局部变量
        n1=eval('x+y') 局部变量
        n2=eval('x+y',locals()) 局部变量
        n3=eval('x+y',globals()) 全局变量
        print(n1,n2,n3)

>>> test_eval()
6 6 3

如果都填写.那么会执行两个作用域
>>> x,y=1,2 全局变量
>>> def test_eval():
        x,y=3,3 局部变量
        n2=eval('x+y',locals(),globals()) 执行最后一个作用域,全局变量
        n3=eval('x+y',globals(),locals())
        print(n2,n3)

>>> test_eval()
3 6

注:eval()使用原因：
1）在编译语言里要动态地产生代码，基本上是不可能的，但动态语言是可以，意味着软件已经部署到服务器上了，
    但只要作很少的更改，只好直接修改这部分的代码，就可立即实现变化，不用整个软件重新加载。
2）在machin learning里根据用户使用这个软件频率，以及方式，可动态地修改代码，适应用户的变化。

娱乐的代码.一行代码写一个可以四则运算的计算器
>>> calc=lambda s: eval(s) 是不是很6

>>> calc('42**2-32//2+4-2')
1750

20. exec(object [，globals [，locals ] ]) 执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码

expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值永远为 None

和eval用法一样,实际上gloabls()是一个字典
>>> s='print(x+y)'
>>> exec(s,{'x':1,'y':2})
3

>>> x,y=1,2
>>> exec(s)
3

21. filter(function, iterable)用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的filter对象

>>> list(filter(lambda x: x%2 ,range(10))) 奇数
[1, 3, 5, 7, 9] 好像也没有什么好说的

注:给一个作业.请算出三位数的水仙花数,不知道水仙花数的可以百度一下.先不要看代码.自己写一下.看看是不是和作者一样

>>> list(filter(lambda s: (s%10)**3+(s//10%10)**3+(s//100)**3==s,range(100,1000)))
[153, 370, 371, 407]

22. float([x]) 将整数和字符串转换成浮点数

>>> float() 默认返回0.0
0.0
>>> float(121) 整数转为浮点数
121.0
>>> float('  3  ') 将字符串转为浮点数.可以有空格.切记复数complex函数是不允许有空格的
3.0

>>> float(' 4 43 43') 不能允许中间有空格,只能是左右可以
Traceback (most recent call last):
  File "", line 1, in 
    float(' 4 43 43')
ValueError: could not convert string to float: ' 4 43 43'

支持科学计数法
>>> float('1e-003')
0.001
>>> float('1e3') 是字符串
1000.0

>>> float(1e3) 不是字符串
1000.0

支持无穷大,大小写不敏感
>>> float('inf') 正无穷大
inf
>>> float('-inf') 负无穷大
-inf
>>> float('INf')
inf

支持不是数字处理,大小写不敏感
>>> float('nan') 这个真的是难(nan)啊.
nan
>>> float('NaN')
nan

23. format(value [，format_spec ])参数无限,格式化字符串,功能强大

>>> '{}{}'.format(1,2) 不指定位置.默认按顺序
'12'

>>> '{1}{0}'.format(1,2) 指定位置.按位置填写
'21'

>>> '{name}{age}'.format(age=1,name='作者') 可以指定名字.按键值对的方式填写
'作者1'

可以填写字典
>>> d=dict(name='hello',age=19)
>>> '{name}-{age}'.format(**d) **d叫拆包
'hello-19'

实际上还可以建立索引
>>> ls=['hello',19]
>>> '{0[0]}-{0[1]}'.format(ls) 是不是很强大
'hello-19'

还可以传入类对象
>>> class test_format:
        s=1
        def test(self):
            return 2

>>> '{0.s}'.format(test_format) 如果是第一个的话.0是可以省略的
'1'

>>> '{.s}'.format(test_format) 切记不可去掉 .
'1'

>>> '{0.test()}'.format(test_format()) 但是不能传入对象调用方法
    Traceback (most recent call last):
      File "", line 1, in 
        '{0.test()}'.format(test_format())
    AttributeError: 'test_format' object has no attribute 'test()'

>>> test_format.s 实际上他去执行的代码是这样的
1

>>> '{{0}}-{0}'.format(1)  {{}}两个{}叫转义,
'{0}-1'

数字格式化应该是format最有魅力的地方

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， 
: 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -
（空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。

>>> '{0:0>3d}'.format(1)  0>表示向左填充0, 3表示是否到达3位数或以上,不足填充,d表示十进制
'001'

>>> '{0:0>4x}'.format(24)
'0018'    

>>> '{0:0>{1}d}'.format(1,3) 3d实际上还可以把3作为变量给输进去
'001'

>>> '{:*>5}'.format(1)
'****1'

                                             *      1颗五角星
                                            ***     3颗五角星
    注:打印一个金字塔                      *****    5颗五角星  
                                           n颗五角星   一直类推 ,格式要一直


    金字塔代码:
    >>> n=8
`   >>> for i in range(1,n):
            s='{0:^{1}}'.format('*'*(i*2-1),n*2-2)
            print(s)`

24. frozenset([iterable]) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

我们看到frozenset函数立马想起了set函数。他们的区别是前者不可改变，后者是可以修改的
如果你要传数字。关输数字是不行的，他要的参数是可迭代对象。所以
>>> frozenset(1)
Traceback (most recent call last):
  File "", line 1, in 
    frozenset(1)
TypeError: 'int' object is not iterable
>>> frozenset((1,)) 你还可以[1],{1}等都行。只要是可以迭代的
frozenset({1})

因为frozenset是不可改变的，所以他可以做成hash值。可以作为字典的key值。
>>> f=frozenset({1,2})
>>> {f:'frozen'}
{frozenset({1, 2}): 'frozen'}

>>> f=set({1,2})
>>> {f:'set'}
Traceback (most recent call last):
  File "", line 1, in 
    {f:'set'}
TypeError: unhashable type: 'set

注：这里就不介绍集合的运算，比如差集，并集啊之类。我主要在set函数重点

25. getattr(obj,name,default=AttributeError) 返回一个对象属性值

object -- 对象。
name -- 字符串，对象属性。
default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

>>> class test_getattr:
        s=1
>>> getattr(test_getattr,'s') 没有该属性会报错
1

>>> getattr(test_getattr,'s1',2) 没有该属性返回2，第三个参数
2

26. globals() 以字典类型返回当前位置的全部全局变量

>>> s='tyoui'
>>> globals() 返回当前全局变量的字典
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': ,
 '__spec__': None, '__annotations__': {}, '__builtins__': , 's': 'tyoui'}

>>> globals()['s']
'tyoui'

27. hasattr(obj,name) 判断对象是否包含对应的属性 obj可以是类对象也可以是实例化对象

>>> class test_hasattr:
            s=1

>>> hasattr(test_hasattr,'s') 存在
True
>>> hasattr(test_hasattr,'s1') 不存在
False

>>> class test_hasattr:
        def test(self):
            return 2

>>> hasattr(test_hasattr,'test') 判断方法。第一个的类对象.第二个是方法引用
True
>>> hasattr(test_hasattr,'test()')
False

28. hash(obj) 用于获取取一个对象（字符串或者数值等）的哈希值

>>> hash('test')
-8467188814980898581
>>> hash('tyoui')
6170064568863603886
>>> hash(1)
1

注：hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关
hash() 函数的对象字符不管有多长，返回的 hash 值都是固定长度的，一般用在矫正文件一致性。
也可以用于简单加密

29. help([obj]) 查看函数或模块用途的详细说明

实际上这只是一个帮助文档。
>>> help([].append) 比如我想看看列表的增加方法
Help on built-in function append:

append(object, /) method of builtins.list instance
    Append object to the end of the list.

30.hex(x) 十进制转为十六进制： x是十进制的整数，返回的结果是十六进制的字符串形式

>>> hex(10) 正整数没问题
'0xa'
>>> hex(-10) 负整数也没有问题
'-0xa'

>>> hex(12.1) 浮点数就报错了
Traceback (most recent call last):
  File "", line 1, in 
    hex(12.1)
TypeError: 'float' object cannot be interpreted as an integer

注：我们这样获得浮点数的十六进制呢？
>>> float.hex(12.3) 利用float.hex(x) 这里的x一点还是浮点数
'0x1.899999999999ap+3'

>>> float.hex(2) 是整数。报错TypeError
Traceback (most recent call last):
  File "", line 1, in 
    float.hex(2)
TypeError: descriptor 'hex' requires a 'float' object but received a 'int'

31.id(obj) 获得对象的内存地址

id这个函数基本上大家都非常熟悉,我就不多说.但是下面的,你们会解释的清楚吗?
>>> a,b=1,1 为什么a=b=1时,id地址居然是一模一样?
>>> id(a)
140729119466320
>>> id(b)
140729119466320

>>> a,b=257,257 为什么a=b=257时.他们的id地址居然不一样?
>>> id(a)
1896796937264
>>> id(b)
1896796937456

为什么?答案是:Python编译器会自动缓存一些对象.比如数字是从[-5,256]之间,看下面的证明过程
>>> a,b=-5,-5
>>> id(a),id(b) 一样
(140729119466128, 140729119466128)

>>> a,b=-6,-6
>>> id(a),id(b) 不一样
(1896796937488, 1896796937392)

>>> a,b=256,256 一样
>>> id(a),id(b)
(140729119474480, 140729119474480)

>>> a,b=257,257 不一样
>>> id(a),id(b)
(1896796937392, 1896796937488)

32. input([prompt]) prompt是任意字符,接受一个标准输入数据，返回为 string 类型

>>> input('是不是很简单:')
是不是很简单:是的
'是的'

33. int(x,base=10) 将一个字符串或数字转换为十进制整型,

x是接受字符串或者数字
base是描述x是什么进制(可以是任意进制),默认是十进制,切记.这里base是指的x.而非输出,输出的都是十进制
返回结果都是十进制的整数

第一种情况:如果只有x参数.那么可以是字符串,可以是数字
>>> int(23) 可以是整数
23
>>> int(32.2) 可以是浮点数
32
>>> int('10') 可以是字符串
10
>>> int(1+2j) 但是不能是复数
Traceback (most recent call last):
  File "", line 1, in 
    int(1+2j)
TypeError: can't convert complex to int
>>> int(0o123) 可以写进制.切记不能写成字符串形式
83

如果字符串里面包含进制符号.那么一定要指出是几进制.
>>> int('0x123') 字符串里面包含0x符号,那么一定要指出是十六进制,正确的写法是:int('0x123',16)或者int(0x10)
Traceback (most recent call last):
  File "", line 1, in 
    int('0x123')
ValueError: invalid literal for int() with base 10: '0x123'

第二种情况:如果base有值,那么x必须填写,并且x只能传输字符串.
>>> int('10',16)  说明字符串里面的是十六进制
16
>>> int('0x123',16) 十六进制转十进制
291
>>> int('231',5) 五进制转十进制,实际上可以是任意进制
66

注:bin函数和这里的oct,int,hex函数有异曲同工之妙,(二进制.八进制.十进制,十六进制),但是他们有稍微不一样的地方,切记

34. isinstance(obj,classInfo) 判断对象是否属于一个已知的类型

object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。实际上这里我们判断的最多的还是基本类型

实际上他和type()十分相似,不过他们还是有很大的区别
首先返回值类型不一样.其次type()不会认为子类是一种父类类型.不考虑继承关系
当然.那么isinstance就会考虑.
>>> isinstance(2,int) 判断2是是否属于int类型,切记不能粗心大意,写成isinstance(int,2),那么这个意思就是int是否属于2类型?当然会报错的
True
>>> isinstance(2,(list,str,int)) 还可以是一个列表
True

>>> class test_isinstance(list):
        pass
>>> isinstance(test_isinstance(),list) 注意,这里传入的是实例对象.而类对象
True

>>> isinstance(test_isinstance,list) 如果是类对象.就会判断失败,
False

>>> type(test_isinstance)

>>> type(test_isinstance())

35. issubclass(class, classinfo)判断参数 class 是否是类型参数 classinfo 的子类

class -- 类。
classinfo -- 类

issubclass和isinstance的区别是他判断的这是单纯的继承关系,没有属性关系.判断的是两个类之间的关系.

>>> issubclass(2,int) 必须是两个类的对象
Traceback (most recent call last):
  File "", line 1, in 
    issubclass(2,int)
TypeError: issubclass() arg 1 must be a class


>>> class test_issubclass(list): 继承list
        pass

>>> issubclass(test_issubclass,list) 判断test_issubclass是否list的子类?切记传的是类对象.
True

36. iter(object[, sentinel]) 用来生成迭代器,第一次参数是要支持迭代器对象,

sentinel -- 参数
如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），
此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
如果被回调函数的返回值等于sentinel，则抛出StopIteration异常，否则返回下一个值.
他返回的是一个迭代对象

第一种情况:参数是第一个的时候,这个很好理解
>>> for i in iter([1,2,3]): 返回一个迭代对象的值
print(i)
1
2
3

第二种情况:如果第二个参数有值代表什么?实际上iter函数会调用实例化对象执行__next__方法.
当__next__返回值等于第二个参数sentinel的值时,停止迭代,否则继续.
>>> class test_iter:
        def __init__(self,start):
            self.start=start
            
        def get_iter(self):
            self.start+=1 累加1,实际上我这里设计的有bug的,因为如果sentinel小于start的话.那么这个就变成无限迭代下去.
            不过你可以加一个判断.当迭代到什么值的时候.抛出StopIteration异常
            return self.start

>>> t=test_iter(10) 实例化,初始化start=10
>>> [i for i in iter(t.get_iter,14)] 当start==14的时候,停止迭代.切记.14不是要迭代14次.,而且迭代的值等于14就停止.
[11, 12, 13]

37.len(obj) 返回对象的长度

>>> len('作者')
2

>>> len([1,2,3])
3

38. list(seq) 将元组或字符串转换为列表,返回列表

关于list函数.也就是列表,在Python中是至关重要.这里要花大量篇幅来详细讲解
我在上面已经详细的讲解过字典类型.这里和字典类型同样重要的列表类型
创建列表的方式:
>>> ls1=[1,2,3] 第一种用[]括号进行创建,也是最常见的创建方式
>>> ls2=list([1,2,3]) 第二种就是用list函数.传入一个可迭代对象进行创建
>>> ls1,ls2
([1, 2, 3], [1, 2, 3])

创建方式很简单,我们重点来说list里面的方法:最常见的有11个方法.我们一个一个的来讲解
 ['append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

第一个:append(obj)方法
>>> ls=[1,2,3]
>>> ls.append(4) 传入一个对象.该方法实际上是在末尾增加元素,并且不改变列表对象.
>>> ls
[1, 2, 3, 4]

第二个:clear()方法
>>> ls.clear() 清除列表
>>> ls
[]

第三个:copy()方法
>>> ls=[1,2,3] 
>>> copy_ls=ls.copy() 实际上该复制的方式也是浅复制
>>> copy_ls 
[1, 2, 3]
请证明一下?证明过程和dict函数证明一样.
>>> ls=[1,2,[1,2]]
>>> copy_ls=ls.copy()
>>> copy_ls[2].append(3)
>>> ls
[1, 2, [1, 2, 3]]

第四个:count(obj)方法
>>> ls
[1, 2, [1, 2, 3]] 
>>> ls.count(1)统计列表中的1,切记他不会递归的去统计.实际上他只会统计第一层元素
1

第五个:extend(iterable)方法
>>> ls.extend([2,3]) 合并列表.实际上参数是一个可迭代对象,这种合并列表的速度是最快的,比+要快得多
>>> ls
[1, 2, [1, 2, 3], 2, 3]

第六个:index(obj,start,end)方法
传入一个搜索的对象,从什么范围开始.范围大小是[start,end],默认的开头是0,end=len(ls)
如果搜索到了返回第一个,搜索不到报错
>>> ls.index(2) 搜索到了再第一个元素
1
>>> ls.index(2,2) 从第二个元素开始搜索
3

第七个:insert(index,obj)方法
在第几个位置插入对象,也是增加元素的方法之一.类似于append方法.返回None
>>> ls
[1, 2, [1, 2, 3], 2, 3]
>>> ls.insert(1,4) 在第一的元素位置插入4
>>> ls
[1, 4, 2, [1, 2, 3], 2, 3]

第八个:pop(index)方法
抛出第一几个元素.其中index就是指出抛出元素位置,如果不指出index.那么默认抛出最后一个,如果index大于列表的长度会报错
返回值是抛出元素的值
>>> ls
[1, 4, 2, [1, 2, 3], 2, 3]
>>> ls.pop(1) 抛出位置1的元素
4
>>> ls
[1, 2, [1, 2, 3], 2, 3]
>>> ls.pop() 抛出最后一个
3
>>> ls
[1, 2, [1, 2, 3], 2]

第九个:remove(obj)返回
这个和pop都是抛出的意思.不过pop是按照位置抛出.而remove是按照对象值抛出
移除成功返回值None,如果要移除的值没有在列表会报ValueError错误
>>> ls
[1, 2, [1, 2, 3], 2]
>>> ls.remove(1) 准确点说叫移除元素1,无返回值
>>> ls
[2, [1, 2, 3], 2] 
>>> ls.remove(2) 只会移除第一个,然后终止遍历
>>> ls
[[1, 2, 3], 2] 第二个2并没有移除掉
    
第十个:reverse()方法.该方法叫反转,意思就是把最后个元素和第一个相换,以此类推
都是在同一个列表进行操作.不会生成新的对象
>>> ls
[[1, 2, 3], 2]
>>> ls.reverse() 反转
>>> ls
[2, [1, 2, 3]]

第十一个:sort(key,reverse)方法
对列表进行排序,默认升序,reverse默认是False,如果改成True,就是降序
key -- 主要是用来进行比较的元素，指定可迭代对象中的一个元素来进行排序。
无返回值,None.实际上是对本身进行操作
>>> ls=[2,6,3,0] 切记.这里的列表排序只能针对同一类型
>>> ls.sort() 默认是升序
>>> ls
[0, 2, 3, 6]
进行降序排序
>>> ls=[2,6,3,0]
>>> ls.sort(reverse=True)
>>> ls
[6, 3, 2, 0]

>>> ls=[1,5,'4'] 不同类型会报错
>>> ls.sort()
Traceback (most recent call last):
  File "", line 1, in 
    ls.sort()
TypeError: '<' not supported between instances of 'str' and 'int'

思考一个问题,我非要int类型和str类型进行比较?怎么做?
>>> ls=[1,5,'4']
>>> def test_ls_sort(elem):
        if isinstance(elem,int): 判断这个元素是int类型
            return str(elem) 转为字符串类型进行返回
        return elem

>>> ls.sort(key=test_ls_sort) 实际上key就像一个map函数一样,这个在后面要讲,其实就是一种映射关系
>>> ls
[1, '4', 5]
实际上还有一种更加简单的写法.这也是Python独特的魅力所在
>>> ls=[1,5,'4']
>>> ls.sort(key=lambda x: str(x) if isinstance(x,int) else x) 
如果是偷懒的话可以这样写:ls.sort(key=lambda x: str(x)) 不建议这样写,简单很好,不过最基本的逻辑还是要保留
>>> ls
[1, '4', 5]

注:最后差一个小知识点:对列表进行操作的其他函数
1、len(list)：列表元素个数 
2、max(list)：返回列表元素最大值 
3、min(list)：返回列表元素最小值 
4、enumerate 用法（打印元素对应的下标）
5、列表切片（list 取值的一种方法）这个就很重要啊
关于切片的使用方法:ls[start:stop:step],从表面意思理解,start是开始.end是结束.step是步长,
>>> ls
[1, '4', 5]
>>> ls[1] 选取位置1
'4'
>>> ls[0:3] 选取位置0到2
[1, '4', 5]
>>> ls[:3] 如果起始位置是0.可以省略不写
[1, '4', 5]
>>> ls[:] 如果结束位置等于列表长度.也是可以省略不写
[1, '4', 5]
>>> ls[::-1] 默认的步长是正数1(从左往右).如果我改写成-1.那么相当于从右往左取
[5, '4', 1]
>>> ls[:100] 如果你的结束位置超过了列表的长度.那么相当于是列表的长度
[1, '4', 5]
>>> ls[100:200] 如果你的起始位置都比列表长.那么返回空列表
[]
并且列表的取值可以负
>>> ls
[1, '4', 5]
>>> ls[:-1] 取负相当于最后一个,类似于:len(ls)-1
[1, '4']
关于更多切片请关注与实现__getitem__魔术方法
证明过程.如下:
>>> class test_slice:
        def __getitem__(self,x): 
            print(x)
>>> t=test_slice()
>>> t[1:3]
slice(1, 3, None) 返回的是切片对象
>>> t[1:4:3]
slice(1, 4, 3)

39. locals() 字典类型返回当前位置的全部局部变量

实际上和globals()函数是不是殊途同归的感觉.不过一个是全局,一个是局部
>>> def test_locals(x):
        s=1
        print(locals()) 打印局部变量
>>> test_locals(3)
{'x': 3, 's': 1}

我们来增加全部变量看看:
>>> def test_locals(x):
        s=1
        print(globals()) 打印全局变量

>>> test_locals(3) 实际上打印出来看不到有x和s变量.
{'__name__': '__main__', '__doc__': None, '__package__': None, 
'__loader__': , 
'__spec__': None, '__annotations__': {}, 
'__builtins__': , 
'test_locals': }

40. map(function, iterable…) 会根据提供的函数对指定序列做映射

function -- 函数
iterable -- 可迭代序列
返回迭代器对象,这个是重要函数
>>> list(map(lambda x:x*2,[1,2,3])) 因为map返回的是map对象.所以要用list转化,
[2, 4, 6]

>>> m=map(lambda x,y:x+y,[1,2,3],[2,3,4]) 多个参数的时候
>>> list(m)
[3, 5, 7]

41. max(*x)参数的最大值，参数可以为序列,返回给定参数的最大值。

>>> max(1,2,3,4) 多个参数,都是同一个类型
4
>>> max([1,5,3,5]) 一个列表,或者可迭代对象
5
 >>> max('a','b')
'b'

42. memoryview(obj)返回给定参数的内存查看对象

所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
obj -- 对象
返回元组列表。
为了给别的代码使用缓冲区里的数据，而不必拷贝，就可以直接使用。
v = memoryview(b'abc123')
print(v[1]) 98
print(v[0]) 97

 >>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]

>>> bytes(v[1:4])
b'bce'

43. min(x,y,z…) 返回参数中最小的值

实际上这个和max()的用法一模一样.不过一个是求最大,一个是求最小而已
>>> min(1,2,3)
1
>>> min([1,2,3])
1

其他用法参考max()

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

iterator -- 可迭代对象
default -- 可选，用于设置在没有下一个元素时返回该默认值，
如果不设置，又没有下一个元素则会触发 StopIteration 异常。

>>> it=iter([1,2,3,4]) 创建一个可以被迭代的对象,参考iter函数
>>> next(it) 只要是可以被迭代的对象,那么这个就可以被执行.
1
>>> next(it)
2

>>> next(it) 但我一直迭代到没有函数值的时候
4
>>> next(it) 报出停止异常
Traceback (most recent call last):
  File "", line 1, in 
    next(it)
StopIteration
>>> next(it,'无') 可以设置default参数.
'无'

45. object() object类是Python中所有类的基类，如果定义一个类时没有指定继承哪个类，则默认继承object类

这个object函数,实际上还真的用的十分之少,唯一用途比较多的就是判断类型的时候
>>> class test_object:
        pass
>>> isinstance(test_object,object)
True

46. oct(x) 一个整数转换成8进制字符串,切记是整数型

这里不像(int)十进制一样.可以传入一个字符串
>>> oct(12) 将十进制转为八进制
'0o14'
>>> oct(0x12) 将十六进制转为八进制
'0o22'

注;这里我提出一个问题.写一个小程序将x进制转为y进制.比如讲5进制转为7进制,12342(5进制)-->???(7进制)
我们这里就利用第三方包

from jtyoui import bs
if __name__ == '__main__':
    print(bs.binary_system(1254, 7, 19)) 参数介绍:1235是要转为的数值.7表示是1235是7进制.19表示要转为19进制

47. open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)用于打开一个文件

file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf-8
errors: 报错级别
1）当指明为’strict’时，编码出错则抛出异常ValueError。
2）当指明为’ignore’时，忽略错误。
3）当指明为’replace’时，使用某字符进行替代模式，比如使用’?’来替换出错的。
4）其它相应还有surrogateescape/xmlcharrefreplacs/backslashreplace。
newline: 区分换行符:参数newline是用来控制文本模式之下，一行的结束字符。可以是None，’’，\n，\r，\r\n等。
closefd: 传入的file参数类型
opener:参数opener是用来实现自己定义打开文件方式。

>>> f=open(r'E:/hello.txt','r') 默认的编码与编译器有关,是encoding='cp936',而我的文件是UTF-8的
>>> f
<_io.TextIOWrapper name='E:/hello.txt' mode='r' encoding='cp936'>
>>> f.read() 报错.编码错误
Traceback (most recent call last):
  File "", line 1, in 
    f.read()
UnicodeDecodeError: 'gbk' codec can't decode byte 0xac in position 25: illegal multibyte sequence

>>> f=open(r'E:/hello.txt',mode='r',encoding='utf-8') 这样就没有事
>>> f.read()
'hello world\nhi author:本人'
 
 >>> f=open(r'E:/hello.txt',mode='r',encoding='utf-8') 按行读取
>>> f.readlines()
['hello world\n', 'hi author:本人']

>>> f=open(r'E:/hello.txt',mode='r',encoding='utf-8')
>>> f.readline() 读取一行
'hello world\n'
 
 返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)
 >>> f.tell()
 13
 
 f.seek(偏移量,[起始位置])
用来移动文件指针
偏移量:单位:比特,可正可负
起始位置:0-文件头,默认值;1-当前位置;2-文件尾
seek()的三种模式：
（1）f.seek(p,0)  移动当文件第p个字节处，绝对位置
（2）f.seek(p,1)  移动到相对于当前位置之后的p个字节
（3）f.seek(p,2)  移动到相对文章尾之前的p个字节
>>> f.seek(0,0)
0
>>> f.readlines()
['hello world\n', 'hi author:本人']
>>> f.tell()
29
注意要使用当前位置和结束位置,那么mode的模式必须是字节模式.也就是说必须有个b
>>> f.seek(0)
0
>>> f.readline() 我有两行数据
'hello world\n'
>>> f.seek(3,1) 报错
Traceback (most recent call last):
  File "", line 1, in 
    f.seek(3,1)
io.UnsupportedOperation: can't do nonzero cur-relative seeks

 注:关于他的写操作,二进制文件操作,请参考mode的设置.更多设置,将在os模块里面详细说明

48. ord© 返回对应的 ASCII 数值，或者 Unicode 数值。

>>> ord('a') 这个返回的ASCII值
97
>>> ord('作') 这个返回的Unicode值
20316

49. pow(x,y[,z]) 返回 x**y（x的y次方） 的值。如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z

>>> pow(2,3) 2**3=8
8
>>> pow(2,3,3) 2**3=8%3=2
2
>>> pow(1.1,2.2) 1.1**2.2=1.2332863005546628
1.2332863005546628
如果有第三参数:那么前两个参数都应该是整数
>>> pow(2.1,2,3) 
Traceback (most recent call last):
  File "", line 1, in 
    pow(2.1,2,3)
TypeError: pow() 3rd argument not allowed unless all arguments are integers

50. print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout)方法用于打印输出，最常见的一个函数。

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

这个方法我就没有什么好说的,是用得最多的一个
>>> print('blog','jtyoui','com',sep='.') 最不让人知道的是这个对象间隔符,默认是空格
blog.jtyoui.com
>>> print('blog','jtyoui','com',sep='.',end='.....') 结尾符,默认是换行
blog.jtyoui.com.....
他甚至还可以写入文件:file -- 要写入的文件对象。

51. property([fget[, fset[, fdel[, doc]]]]) 函数的作用是在新式类中返回属性值

fget -- 获取属性值的函数
fset -- 设置属性值的函数
fdel -- 删除属性值函数
doc -- 属性描述信息

定义一个类
>>> class test_property:
        def __init__(self,x):
            self.__x = x
        def getx(self):
            return self.__x
        def setx(self, value):
            self.__x = value
        def delx(self):
            del self.__x
        x = property(getx, setx, delx, "x property")

>>> t=test_property(3) 实例化对象
>>> t.x  实际上调用的是t.getx
3
>>> t.x=4 实际上调用的是t.setx(4)
>>> t.x
4
>>> del t.x 实际上调用的是:t.delx
>>> t.x 没有了,报错
Traceback (most recent call last):
  File "", line 1, in 
    t.x
  File "", line 5, in getx
    return self._x
AttributeError: 'test_property' object has no attribute '_x'

实际上我们用得更多的是下面这种.
class test_property:
    def __init__(self,x):
        self.__x = x
    @property
    def x(self):
        """x property"""
        return self.__x
    @x.setter
    def x(self, value):
        self.__x = value
    @x.deleter
    def x(self):
        del self.__x

52. range(start, stop[, step]) 返回的是一个可迭代对象

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


>>> list(range(3)) 一个参数,默认是从0开始
[0, 1, 2]
>>> list(range(3,6)) 范围[3,6)
[3, 4, 5]
>>> list(range(3,10,3)) 步长为3
[3, 6, 9]
>>> list(range(3,1,-1)) 如果步长是负数,那么起始位置应该大于结束位置
[3, 2]

53. repr(obj)将对象转化为供解释器读取的形式,返回一个对象的 string 格式。

>>> s='jtyoui'
>>> repr(s)
"'jtyoui'"

>>> d = {'google': 'google.com'}
>>> repr(d)
"{'google': 'google.com'}"

是不是感觉好像鸡肋一样,其实不是,他其实和str()有点类似.不过str是给人看的,repr是给机器看的.
下面这个等式恒成立
obj==eval(repr(obj))
但是:obj==eval(str(obj)) 就要报错.(除去特殊情况)

请问为什么???
答案是:repr在转化对象的时候加了字符串.而eval在执行字符串的时候,会忽略第一层字符串,相当于字符串里面代码可以被执行一样
如果是str,那么eval就直接去执行字符串里面的代码,这个时候字符串就相当于变量去执行,当然要报错!
>>> obj='有问题吗'
>>> obj==eval(str(obj))
Traceback (most recent call last):
  File "", line 1, in 
    obj==eval(str(obj))
  File "", line 1, in 
NameError: name '有问题吗' is not defined

我说了除去特殊情况,那请问在什么情况下:obj==eval(str(obj))不但不报错,而且还是恒成立????
答案很显然,在有无字符串都不影响的对象下,自然成立,那是不是数值型,对的,如果对象是数值型两个都成立.
>>> obj=1
>>> obj==eval(str(obj)) 整数没问题
True

>>> obj=-12132.2313
>>> obj==eval(str(obj)) 浮点数也没有问题
True

54. reversed(seq) 返回一个反转的迭代器

seq -- 要转换的序列，可以是 tuple, string, list 或 range。
切记seq不是可迭代对象,而是序列,比如map也是可迭代对象不过这里就不能用他
>>> list(reversed('jtyoui')) 反转字符串
['i', 'u', 'o', 'y', 't', 'j']

>>> list(reversed([1,2,3])) 列表反转
[3, 2, 1]

55. round(x [, n] ) 返回浮点数x的四舍五入值。

x -- 数值型。
n -- 表示保留小数点x位，默认值为 0。
>>> round(6) 整数没问题
6
>>> round(6.233,1) 在保留1位小数点
6.2
>>> round(0.52) 浮点数
1
>>> round(-0.52) 负浮点数
-1

56. set([iterable]) set() 函数创建一个无序不重复元素集，可进行关系测试.

下面是set方法的所有属性,我会一个一个的讲解
['add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 
'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 
'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
首先创建set对象
>>> s={1,'a',1.2,object} 一种是用{}进行创建
>>> s
{1, 'a', , 1.2}
>>> s=set([1,'a',1.2,object]) 另一种是用set函数进行创建
>>> s
{1, 'a', , 1.2}

>>> s.add(4) 增加元素
>>> s
{1, 'a', 1.2, 4, }

>>> s.clear() 清除数据
>>> s
set()

copy()复制方法,pop()抛出方法,remove()移除方法,在序列中都是通用的,不在讲解

下面都是关系测试:
>>> x={1,2,3}
>>> y={2,4,6}

差集,意思的除去x中包含y的元素
>>> x.difference(y)
{1, 3}
>>> x-y 和上面一样.意思效果都是一样
{1, 3}

>>> x.difference_update(y) 差集更新,实际上就是把返回的结果更新到x上,类似于: x-=y
>>> x
{1, 3}

>>> x={1,2,3}
>>> x.discard(1) 相当于删除元素,存在1就删除.他和remove不一样的是,discard找不到不报错.而remove要报错的
>>> x
{2, 3}

交集
>>> x={1,2,3}
>>> y={2,3,4}
>>> x.intersection(y) 和:x&y 效果一样.
{2, 3}
intersection_update返回类似于 :x=x.intersection(y) 多了一步赋值操作

>>> x={1,2,3}
>>> y={2,3,4}
>>> x.isdisjoint(y) 判断集合x中没有包含集合y的元素
False 注意,这里是没有包含才是true,包含了false

>>> x={1,2}
>>> y={1,2,3}
>>> x.issubset(y) 判断x是否是y的一部分
True

>>> x.issuperset(y) 判断是x是不是y的父亲,也就是全集
False

>>> x={1,2}
>>> y={1,2}
>>> x.issubset(y) 注意我们知道.当两个集合在一起的时候,也是子集.也是全集
True
>>> x.issuperset(y)
True

>>> x={1,2,3}
>>> y={3,4}
>>> x.union(y) 并集类似于:x|y
{1, 2, 3, 4}

>>> x={1,2,3}
>>> x.update(['a',3,4]) 更新数据.实际上就是多个数据一起添加
>>> x
{1, 2, 3, 4, 'a'}

>>> x={1,2,3}
>>> y={2,3,5}
>>> x.symmetric_difference(y) 返回不要xy中重复的元素
{1, 5}
symmetric_difference_update 实际上就是多了一步赋值操作

注:实际上用+-^&可以做到集合关系,不过不建议这样做.建议使用set里面的方法来调用,有更加的可读性和避免错误
给一个问题,在集合里面大有铭鼎的笛卡尔集怎么生成?
>>> x={1,2,3}
>>> y={4,5,7}
>>> import itertools
>>> list(itertools.product(x,y))
[(1, 4), (1, 5), (1, 7), (2, 4), (2, 5), (2, 7), (3, 4), (3, 5), (3, 7)]

57. setattr(object, name, value)对应函数 getattr()，用于设置属性值，该属性不一定是存在的

object -- 对象。
name -- 字符串，对象属性。
value -- 属性值。


>>> class test_setattr:
        name='jtyoui'
>>> getattr(test_setattr,'name') 复习一下getattr的用法
'jtyoui'
>>> setattr(test_setattr,'age',18) 设置不存在的值,如果存在相当于修改数值
>>> test_setattr.age 调用
18

思考一个问题?我在上面传入的是类对象,而不是类的实例化对象.现在增加了age属性.请问我重新实例化对象调用age会报错吗??
>>> t=test_setattr() 实例化
>>> t.age 没有报错.而且有值?请问为什么?
18

如果我setattr传入的是实例化对象.那么重新实例化类还能调用我新生产的属性吗?
>>> setattr(test_setattr(),'age1',20) 我传入实例化对象
>>> t1=test_setattr() 重新实例化对象
>>> t1.age1 没有这个值?报错了.为什么?
Traceback (most recent call last):
  File "", line 1, in 
    t1.age1
AttributeError: 'test_setattr' object has no attribute 'age1'

如果你要是理解了什么是类对象,什么是类的实例化对象,那么这个问题就很好理解,我其实已经在上面的函数中讲述过,
类的实例化对象其实是复制了类对象,每次实例化相当于把类对象作为蓝本进行复制修改.

58. slice(start, stop[, step])实现切片对象,返回一个切片对象。

start -- 起始位置,如果只有一个参数.默认起始位置是0,填写的是结束位置
stop -- 结束位置
step -- 间距
切片都可以用在序列中,实际上对象是去实现了def __getitem__(self, item):魔法函数
>>> ls=[1,2,3,4,5,6]
>>> s=slice(4) 一个参数.默认是[0,4) 4不包括
>>> ls[s]
[1, 2, 3, 4]
>>> s=slice(1,5)
>>> ls[s]
[2, 3, 4, 5]

注:多学一点魔法函数有利于提高效率和减少代码冗余

59. sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作。

iterable -- 可迭代对象。
key -- 主要是用来进行比较的元素，只有一个参数，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
实际上,这个函数我们在讲列表的时候已经讲过,sort()和这个一模一样,只不过sort是专门为列表服务,
而sorted是专门为可迭代对象服务
这里就不多说了,可以查看list函数,我直接把list里面的sort方法复制过来,看下面代码
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
>>> ls=[2,6,3,0] 切记.这里的列表排序只能针对同一类型
>>> sorted(ls) 默认是升序
[0, 2, 3, 6]
进行降序排序
>>> sorted(ls,reverse=True)
[6, 3, 2, 0]

60. @staticmethod 返回函数的静态方法

class test_staticmethod:
    @staticmethod
    def f():
        print('jtyoui');
 
test_staticmethod.f() 静态方法无需实例化
test_staticmethod().f() 也可以实例化后调用
该方法不要多说

61. str(obj)对象转化为适于人阅读的形式。

字符串是所有编程语言里面的一个核心类型,非常重要
['capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format',
'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 
'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans',
'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines',
'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
 
>>> s='abc'
>>> s.capitalize() 首字母大写
'Abc'
 
 >>> s='ABC'
>>> s.casefold() 全部转为小写
'abc'

>>> s.center(6) 居中字符串,默认填充的是空格
' ABC  '
>>> s.center(6,'*') 填充*号
'*ABC**'

x.count(str,__start,__end) 指定开始和结束范围来统计某字符串的个数
>>> s='dhadhh'
>>> s.count('h') 统计h字符串的个数,默认是从0位置到结束
3
>>> s.count('h',3,6) 位置从3到6
2
>>> s.count('h',3) 从位置3到结束
2

>>> s.encode('utf-8') 转为UTF-8编码
b'dhadhh'

>>> s
'dhadhh'
>>> s.endswith('h') 以h为结尾?
True

>>> s='I am \t hello'
>>> s.expandtabs() 把\t用空格代替,我暂时还不知道这个有什么用!
'I am     hello'

>>> s
'I am \t hello'
>>> s.find('h') 查找字符串的位置
7
>>> s.find('h',8) 这里有两个参数,查找位置的起始和结束,这里和count里面的参数一致
-1 返回-1表示找到失败

>>> '{}'.format('a') 格式化字符串参考上面的format函数
'a'

index返回和find方法一致,不一样的地方是index没有找到不是返回-1.而是直接报错

>>> s='abc123?'
>>> s.isalnum() 不能包含符号字符串
False 包含就是假

>>> s='acv在'
>>> s.isascii() 是否都是ASCII值
False

>>> s='abh12'
>>> s.isalpha() 字符串中可以有大小写，但不可以有数字和符号
False

像这种方法还有很多,比如:isdecimal(),isdigit()
>>> s='abh12'
>>> s.isdigit() 是否全是数字字符串
False
>>> s='21'
>>> s.isdigit()
True
>>> s.isdecimal()
True

>>> s='abc12!'
>>> s.isidentifier() 用于判断字符串是否是有效的 Python 标识符，可用来判断变量名是否合法
False

>>> s='abc12!'
>>> s.islower() 字母全是小写
True

>>> s='一二三四12'
>>> s.isnumeric() 可以包含中文的数字
True
>>> s.isprintable() 是否可以被打印
True

>>> s='    '
>>> s.isspace() 判断字符串是否只有空格
True
>>> s='    1'
>>> s.isspace()
False

>>> s='i am love'
>>> s.title() 每个单词的首字母都大写
'I Am Love'

>>> s='i am love'
>>> s.istitle() 每个单词的首字母都是大写的吗?
False

>>> s='12!djkaK'
>>> s.isupper() 每个字母都是大写的吗?
False
>>> s='121L'
>>> s.isupper()
True

>>> ':'.join(['a','b']) 字符串拼接
'a:b'

>>> s='abc'
>>> s.ljust(6) 左对齐.和center()方法一样的用法
'abc   '
>>> s.ljust(6,'*')
'abc***'

>>> s='ABD'
>>> s.lower() 把每个字母都转为小写字母
'abd'

>>> s='abc'
>>> s.upper() 将每个小写字母转为大写字母
'ABC'

>>> s='  aaashdha'
>>> s.lstrip() 去除左边的空格
'aaashdha'
>>> s='aah'
>>> s.lstrip('a') 去除左边的a字母
'h'

>>> s='abcdfghdb'
>>> s.partition('d') 从左往右第一个进行分段.返回元组的形式
('abc', 'd', 'fghdb')
>>> s.split('d') 从左往右进行分割,一直进行到最后一个
['abc', 'fgh', 'b']

>>> s='abca'
>>> s.replace('a','A') 替换.将a替代为A
'AbcA'
>>> s.replace('a','A',1) 第三个参数是替换的次数,默认是全部替换,1表示替换一次.如果替换次数大于存在个数,默认全部替换
'Abca'

rfind和find功能一样.用法一样.不过一个是从左往右.一个是从右往左
rindex和index一样,方向不同而已
rjust和just一样.都是方向不同而已
rpartition和partition一样,方向不同而已
rsplit和split一样,方向不同而已
rstrip和lstrip一样,方向不同而已

>>> s='i am \n love'
>>> s.splitlines() 换行符分段
['i am ', ' love']

>>> s
'i am \n love'
>>> s.startswith('i') 以什么开头,用法和endswith一样
True

strip相当于lstrip+rstrip

>>> s='A am Love'
>>> s.swapcase() 大写转小写.小写转大写
'a AM lOVE'

>>> s
'A am Love'
>>> s.zfill(10) 左对齐.填充0
'0A am Love'

>>> ''.maketrans('ab','好坏') 相当于第一个参数是key.第二个参数是value,映射成一个字典类型
{97: 22909, 98: 22351}

>>> 'ab'.translate(s) 翻译的过程,相当于把a映射成好.b映射成坏
'好坏'
>>> 'a--b'.translate(s) 是一个映射的过程
'好--坏'

注:字符串的相乘等价于复制
>>> s='abc'
>>> s*3
'abcabcabc'
字符串中的+相当于拼接,但是不推荐使用
>>> s
'abc'
>>> s+s
'abcabc'

62. sum(iterable[, start]) 方法对可迭代对象进行求和计算

iterable -- 可迭代对象，如：列表、元组、集合。
start -- 指定相加的参数，如果没有设置这个值，默认为0。
只要是数值型就可以
>>> sum([1,2,3]) 没有start
6
>>> sum([1,2,3],1) 有start,累加结束之后最后加start
7
>>> sum([1+2j,2+3j],1+1j) 复数都可以
(4+6j)

>>> sum(1,2) 这样是不可以的
Traceback (most recent call last):
  File "", line 1, in 
    sum(1,2)
TypeError: 'int' object is not iterable

63. super(type[, object-or-type]) 函数是用于调用父类(超类)的一个方法

type -- 类。
object-or-type -- 类，一般是 self

class A:
    def __init__(self):
        super() 可以直接这样实例化
        super(A,self) 这个也是没有问题的

64. tuple(seq) 函数将序列转换为元组,元组与列表类似，不同之处在于元组的元素不能修改。

元组的内置方法很少,就两个
'count', 'index'
>>> s=(1,) 如果只有一个元素.切记要加一个逗号
>>> s
(1,)
>>> s=tuple([1,2]) 传入序列
>>> s
(1, 2)

元组一旦创建不可修改增加
>>> s=(1,1,1,2)
>>> s.count(1) 统计1的个数
3

>>> s.index(2) 查找元素2的位置
3

>>> s[3]
2

>>> s[3]=4 不支持修改
Traceback (most recent call last):
  File "", line 1, in 
    s[3]=4
TypeError: 'tuple' object does not support item assignment

65. type(name, bases, dict) 函数如果你只有第一个参数则返回对象的类型，三个参数都有则返回新的类型对象。

name -- 类的名称。
bases -- 基类的元组。实际上是继承谁
dict -- 字典，类内定义的命名空间变量。

>>> type(1) 一个参数实际上是返回对象类型

>>> type('a')


>>> x=type('test_type',(object,),{'t':1}) 这个实际上等价于类
>>> x

>>> x.t
1

注:type和isinstance的区别在上面就讲过.那有没有觉得type和lambda有异曲同工之妙呢?一个创建方法,一个是类

66. vars([object]) 返回对象object的属性和属性值的字典对象

>>> class test_vars:
        s=1
        def __init__(self,x):
            self.x=x
>>> vars(test_vars) 类对象
mappingproxy({'__module__': '__main__', 's': 1, '__init__': ,'__doc__': None})
>>> vars(test_vars(2)) 实例化对象
{'x': 2}
>>> vars(test_vars(2))['x']=3 实例化对象的键值对是可以被修改的
>>> vars(test_vars)['s']=3 类对象的键值对是不可以被修改的
Traceback (most recent call last):
  File "", line 1, in 
    vars(test_vars)['s']=3
TypeError: 'mappingproxy' object does not support item assignment

注:请思考一个问题.locals()和vars()的区别的????

67. zip(iterable…)将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象

iterabl -- 一个或多个迭代器;
这样做的目的是效率高节约内存,我经常叫zip为并行迭代器
>>> a=[1,2,3]
>>> b=[2,3,4]
>>> list(zip(a,b))
[(1, 2), (2, 3), (3, 4)]

注:给一个问题,现在有两个列表,一个是装key,一个是装value,现在将key和value组装成键值对(key-value)也就是字典
>>> key=['a','b','c']
>>> value=[1,2,3]
>>> dict(zip(key,value)) 其实我在dict函数已经讲过,不过那个时候不知道zip是干嘛的.现在应该能明白了吧!
{'a': 1, 'b': 2, 'c': 3}

68. import(name[, globals[, locals[, fromlist[, level]]]]) 函数用于动态加载类和函数 。

　import指令做了两件事：1）搜索module，2）绑定到局部变量
　　内置函数__import__()只做了一件事：搜索module
　　import指令执行过程中是调用__import__()来完成Module检索的。
搜索module的过程：

在了解搜索的过程前，先来了解一下内部实现中的几个角色：
         a）已经搜索过的module会存在于一个module缓存（sys.modules）中。
         b）finders | importers: 用于搜索module在哪里，找到后返回的是module-spec 
                    (包含Module在哪里，该用那个loader进行加载等信息)。
                    其中finders是从build-in 模块中找，importers是从其他位置找。
                    importers是可扩展的，可以支持文件系统某个路径、zip、urls。
         c）loaders: 依据modulespec 进行加载，生成python中的module
                    module = modulespec.loader.load_module(modulespec.name)
搜索过程如下：
1）如果要搜索的module 的name 在缓存（sys.modules ）中，则进行如下操作：
      1.1）如果值是None，抛出 ModuleNotFoundError 
      1.2）值不是None，直接返回值
2）由finders从内置模块里找，找不到由importer去找，importers也找不到，
             module的name到缓存，值为None，然后raise ModuleNotFoundError。
             在使用importers去找的时候，如果发现了有.pyc，需要先检查.pyc是否最新。
             找到后，返回 生成创建一个module-spec
3）由module-spec中的loader去加载并执行module：
             module = modulespec.loader.load_module(modulespec.name)
             sys.modules[modulespec.name] = module
             modulespec.loader.exec_module(module)
4）最终没有找到，记录module的name到缓存，值为None，然后 raise ModuleNotFoundError

#index.py
def sayHello():
    print('hello index')
    
#mian.py
index = __import__('index')
index.sayHello()