六、Python-python基础（一）-- 内置函数

一、lambda 表达式

可以将简单的函数表示为lambda表达式

 

def fun1(a,b): #普通函数
    return a > b

t = lambda a,b: a > b #lambda表达式

print(t(1,2)) #调用lambda表达式

 

 

二、内置函数

# functions

def abs(*args, **kwargs): # real signature unknown
    """ 返回数据的绝对值t. """
    pass

def all(*args, **kwargs): # real signature unknown
    """ 如果集合的每个元素都是真，则返回真
    Return True if bool(x) is True for all values x in the iterable.
    
    If the iterable is empty, return True.
    """
    pass

def any(*args, **kwargs): # real signature unknown
    """ 如果集合的一个元素为真，则返回真。如果是空集合，返回False
    Return True if bool(x) is True for any x in the iterable.
    
    If the iterable is empty, return False.
    """
    pass

def ascii(*args, **kwargs): # real signature unknown
    """ 去对象的类中查找_repr_，获得它的返回值
    Return an ASCII-only representation of an object.
    
    As repr(), return a string containing a printable representation of an
    object, but escape the non-ASCII characters in the string returned by
    repr() using \\x, \\u or \\U escapes. This generates a string similar
    to that returned by repr() in Python 2.
    """
    pass

def bin(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """ 将数值转换为2进制
    Return the binary representation of an integer.
    
       >>> bin(2796202)
       '0b1010101010101010101010'
    """
    pass

def callable(i_e_, some_kind_of_function): # real signature unknown; restored from __doc__
    """ 判断函数是可调用的
    Return whether the object is callable (i.e., some kind of function).
    
    Note that classes are callable, as are instances of classes with a
    __call__() method.
    """
    pass

def chr(*args, **kwargs): # real signature unknown
    """ 返回一个数值对应的 ASCII 对应的字符。 Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff. """
    pass



def dir(p_object=None): # real signature unknown; restored from __doc__
    """ 返回一个对象，内部可以使用的方法

li = []
print(dir(li))

    dir([object]) -> list of strings
    
    If called without an argument, return the names in the current scope.
    Else, return an alphabetized list of names comprising (some of) the attributes
    of the given object, and of attributes reachable from it.
    If the object supplies a method named __dir__, it will be used; otherwise
    the default dir() logic is used and returns:
      for a module object: the module's attributes.
      for a class object:  its attributes, and recursively the attributes
        of its bases.
      for any other object: its attributes, its class's attributes, and
        recursively the attributes of its class's base classes.
    """
    return []

def divmod(x, y): # known case of builtins.divmod
    """ 求一个除的 商和余数  
Return the tuple ((x-x%y)/y, x%y).  Invariant: div*y + mod == x. """
    return (0, 0)

def eval(*args, **kwargs): # real signature unknown
    """  得到字符串中的表达式结果

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

def exec(*args, **kwargs): # real signature unknown
    """ 执行 字符串 中的命令

exec('print(2) if 1 >2  else print(1)')

    Execute the given source in the context of globals and locals.
    
    The source may be a string representing one or more Python statements
    or a code object as returned by compile().
    The globals must be a dictionary and locals can be any mapping,
    defaulting to the current globals and locals.
    If only globals is given, locals defaults to it.
    """
    pass

def exit(*args, **kwargs): # real signature unknown
    pass

def format(*args, **kwargs): # real signature unknown
    """ 数据格式化

a = 'i am {0}, {1}'
print(a.format('yan',10))

    Return value.__format__(format_spec)
    
    format_spec defaults to the empty string
    """
    pass



def globals(*args, **kwargs): # real signature unknown
    """ 获取当前的所有全局变量
    Return the dictionary containing the current scope's global variables.
    
    NOTE: Updates to this dictionary *will* affect name lookups in the current
    global scope and vice-versa.
    """
    pass


def help(): # real signature unknown; restored from __doc__
    """ 获取一个了 对象 的详细介绍
    Define the builtin 'help'.
    
        This is a wrapper around pydoc.help that provides a helpful message
        when 'help' is typed at the Python interactive prompt.
    
        Calling help() at the Python prompt starts an interactive help session.
        Calling help(thing) prints help for the python object 'thing'.
    """
    pass

def hex(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """  十进制转换十六进制
    Return the hexadecimal representation of an integer.
    
       >>> hex(12648430)
       '0xc0ffee'
    """
    pass

def id(*args, **kwargs): # real signature unknown
    """  获取一个对应的内存地址 
    Return the identity of an object.
    
    This is guaranteed to be unique among simultaneously existing objects.
    (CPython uses the object's memory address.)
    """
    pass

def input(*args, **kwargs): # real signature unknown
    """  获取用户的键盘输入
    Read a string from standard input.  The trailing newline is stripped.
    
    The prompt string, if given, is printed to standard output without a
    trailing newline before reading input.
    
    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
    On *nix systems, readline is used if available.
    """
    pass

def isinstance(x, A_tuple): # real signature unknown; restored from __doc__
    """ 判断对象的类型

a = [11]
print(isinstance(a,list))

    Return whether an object is an instance of a class or of a subclass thereof.
    
    A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
    check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
    or ...`` etc.
    """
    pass

def issubclass(x, A_tuple): # real signature unknown; restored from __doc__
    """ 判断 是不是X的子类。
    Return whether 'cls' is a derived from another class or is the same class.
    
    A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to
    check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)
    or ...`` etc.
    """
    pass

def iter(source, sentinel=None): # known special case of iter
    """  将一个可迭代对象，通过next()来获取下一个值
    iter(iterable) -> iterator
    iter(callable, sentinel) -> iterator
    
    Get an iterator from an object.  In the first form, the argument must
    supply its own iterator, or be a sequence.
    In the second form, the callable is called until it returns the sentinel.
    """
    pass

def len(*args, **kwargs): # real signature unknown
    """获得一个集合的长度 Return the number of items in a container. """
    pass

def license(*args, **kwargs): # real signature unknown
    """
    interactive prompt objects for printing the license text, a list of
        contributors and the copyright notice.
    """
    pass

def locals(*args, **kwargs): # real signature unknown
    """ 获得当前作用域的局部变量
    Return a dictionary containing the current scope's local variables.
    
    NOTE: Whether or not updates to this dictionary will affect name lookups in
    the local scope and vice-versa is *implementation dependent* and not
    covered by any backwards compatibility guarantees.
    """
    pass

def max(*args, key=None): # known special case of max
    """ 获得最大值
    max(iterable, *[, default=obj, key=func]) -> value
    max(arg1, arg2, *args, *[, key=func]) -> value
    
    With a single iterable argument, return its biggest item. The
    default keyword-only argument specifies an object to return if
    the provided iterable is empty.
    With two or more arguments, return the largest argument.
    """
    pass

def min(*args, key=None): # known special case of min
    """  获得最小值
    min(iterable, *[, default=obj, key=func]) -> value
    min(arg1, arg2, *args, *[, key=func]) -> value
    
    With a single iterable argument, return its smallest item. The
    default keyword-only argument specifies an object to return if
    the provided iterable is empty.
    With two or more arguments, return the smallest argument.
    """
    pass

def next(iterator, default=None): # real signature unknown; restored from __doc__
    """与iter 一起使用。 iter 创建可迭代对象。 使用next 每次得到一个数据

a = iter([11,22,33,44])
print(next(a))
print(next(a))

    next(iterator[, default])
    
    Return the next item from the iterator. If default is given and the iterator
    is exhausted, it is returned instead of raising StopIteration.
    """
    pass

def oct(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """ 十进制转换八进制
    Return the octal representation of an integer.
    
       >>> oct(342391)
       '0o1234567'
    """
    pass

def open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True): # known special case of open
    """ 打开文件操作
    Open file and return a stream.  Raise IOError upon failure.
   
    pass

def ord(*args, **kwargs): # real signature unknown
    """ 获取一个字符的的ASCII数值 Return the Unicode code point for a one-character string. """
    pass

def pow(*args, **kwargs): # real signature unknown
    """获得一个数据的的指数
    Equivalent to x**y (with two arguments) or x**y % z (with three arguments)
    
    Some types, such as ints, are able to use a more efficient algorithm when
    invoked using the three argument form.
    """
    pass

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
    """ 打印
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
    """
    pass


def repr(obj): # real signature unknown; restored from __doc__
    """
    Return the canonical string representation of the object.
    
    For many object types, including most builtins, eval(repr(obj)) == obj.
    """
    pass

def round(number, ndigits=None): # real signature unknown; restored from __doc__
    """ 数据四舍五入
    round(number[, ndigits]) -> number
    
    Round a number to a given precision in decimal digits (default 0 digits).
    This returns an int when called with one argument, otherwise the
    same type as the number. ndigits may be negative.
    """
    return 0


def sorted(*args, **kwargs): # real signature unknown
    """ 排序
    Return a new list containing all items from the iterable in ascending order.
    
    A custom key function can be supplied to customise the sort order, and the
    reverse flag can be set to request the result in descending order.
    """
    pass

def sum(*args, **kwargs): # real signature unknown
    """ 数值求和
    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
    
    When the iterable is empty, return the start value.
    This function is intended specifically for use with numeric values and may
    reject non-numeric types.
    """
    pass

    def close(self):
        '''关闭文件  Raises new GeneratorExit exception inside the generator to terminate the iteration.'''
        pass

 

 

三、进制转换

  bin() :十进制转换二进制

  oct()：十进制转换八进制

  int()：十进制转换十进制

  hex()：十进制转换十六进制

 

 如果将其他进制转换为十进制

  

print(int('0b110',base = 2))
print(int('0o110',base = 8))
print(int('0x11',base = 16))

 

四、内置函数的排序

 实现字符串的排序， 按照首字母排序。 顺序：字符串包含 数值、包含大写、包含小写、包含中文

a = ['11','22','abc','ABC', 'db','中文']
li = sorted(a)

for item in li:
    print(item)


C:\Python35\python.exe D:/python/decode.py
11
22
ABC
abc
db
中文

 

五、随机验证码

 主要思路，使用random.randrange()来生成随机的数值。 使用char()将数值转换为字符。

import random
temp = ''

for i in range(6):
     a = random.randrange(0,4)
     if a==2 or a ==4:
         rad1 = random.randrange(65,91)
         c1 = chr(rad1)
         temp = temp + c1
     else:
         rad2 = random.randrange(0,9)
         c1 = str(rad2)
         temp = temp + c1
print(temp)