Python内置函数

# abs(x) x -- 数值表达式，可以是整数，浮点数，复数。
#
print("-26的绝对值为：",abs(-26)) #  -26的绝对值为：26
#

# dict 语法：
#
# class dict(**kwarg)
# class dict(mapping, **kwarg)
# class dict(iterable, **kwarg)
# 参数说明：
#
# **kwargs -- 关键字
# mapping -- 元素的容器。
# iterable -- 可迭代对象。
#
print("创建空字典：", dict()) #创建空字典：{}
print("传入关键字: ", dict(a='a', b='b', t='t')) # 传入关键字: {'a': 'a', 'b': 'b', 't':'t'}
print(dict(zip(['one', 'two', 'three'], [1, 2, 3]))) # 映射函数方式来构造字典 {'one': 1, 'two': 2, 'three': 3}
print(dict([('one', 1), ('two', 2), ('three', 3)]))
# 可迭代对象方式来构造字典 {'one': 1, 'two': 2,'three': 3}
#

# help([object])
#
a =list()
print(help(a.append)) # 显示list的append方法的帮助
# Help on built-in function append:
# append(object, ) method of builtins.list instance
# Append object to the end of the list.
#
# None
#

# min( x, y, z, .... )
#
print ("min(-20, 100, 400) : ", min(-20, 100, 400)) # -20
#
#

# setattr(object, name, value)
# 参数
# object -- 对象。
# name -- 字符串，对象属性。
# value -- 属性值。
#
# 如果属性不存在会创建一个新的对象属性，并对属性赋值
class A():
    name = yc1993


a = A()
setattr(a, age, 28)
print(a.age) # 28
#

# 元素除了是 0、空、None、False 外都算 True。
# 函数相当于：
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True
# all(iterable) # iterable -- 元组或列表
print(all(['a', 'b', 'c', 'd'])) #列表list，元素都不为空或0 True
print( all(['a', 'b', '', 'd'])) #列表list，存在一个为空的元素 False
print(all([0, 1, 2, 3])) # 列表list，存在一个为0的元素 False
print(all([])) # 空列表 True
print(all(())) # 空列表 True

# hex(x) x -- 一个整数
print("789的16进制数为:",hex(789)) # 789的16进制数为：0x315
#

# next() 函数要和生成迭代器的 iter() 函数一起使用。
# next(iterable[, default])
# 参数说明：
#
# iterable -- 可迭代对象
# default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发StopIteration 异常。
#
# 首先获得Iterator对象:
# it = iter([1, 2, 3, 4, 5])
# # 循环:
while True:
    try:
    # 获得下一个值:
        x = next(it)
        print(x, type(x))
    except StopIteration:
    # 遇到StopIteration就退出循环
        break

# class slice(stop)
# class slice(start, stop[, step])
# start -- 起始位置
# stop -- 结束位置
# step -- 间距
myslice = slice(5) # 设置截取5个元素的切片
myslice
arr = range(10)
print(arr)
print(arr[myslice])
# 截取 5 个元素

# iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
# 元素除了是 0、空、FALSE 外都算 TRUE。
#
# 函数等价于
def any(iterable):
    for element in iterable:
        if element:
        return True
    return False
print( any(['a', 'b', '', 'd'])) # 列表list，存在一个为空的元素 True
print(any([0, '', False])) # 列表list,元素全为0,'',false

# CPython 中 id()函数用于获取对象的内存地址。
# id([object]) object -- 对象。返回值是内存地址
a = yc1993xm1996
print(id(a)) # 2163314263536

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

# import math
#
math.pow( x, y )


print(pow(3, 2)) # 9

# enumerate(sequence, [start=0])

# sequence -- 一个序列、迭代器或其他支持迭代对象。
# start -- 下标起始位置。
xm = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(xm)))   #[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

# 我们可以使用 list() 转换来输出列表。
#
# 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
# zip([iterable, ...]) iterable 一个或多个迭代器
yc = [1, 2, 4, 5]
xm = [6, 7, 8, 9]
print(list(zip(yc, xm))) # [(1, 6), (2, 7), (4, 8), (5, 9)]

# 第一个参数 function以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
# map(function, iterable, ...)
# function -- 函数
# iterable -- 一个或多个序列
def squre(x):
 return x*2
yc =[2, 4, 5, 6, 7]
print(list(map(squre, yc))) # [4, 8, 10, 12, 14]

# 使用 open() 函数一定要保证关闭文件对象，即调用close() 函数。
# 就是file()函数
# open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。
# open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None,closefd=True, opener=None)
# file: 必需，文件路径（相对或者绝对路径）。
# mode: 可选，文件打开模式
# buffering: 设置缓冲
# encoding: 一般使用utf8
# errors: 报错级别
# newline: 区分换行符
# closefd: 传入的file参数类型
# opener:
# t ：文本模式 (默认)。
# x ：写模式，新建一个文件，如果该文件已存在则会报错。
# b ：二进制模式。
# + ：打开一个文件进行更新(可读可写)。
# U ：通用换行模式（不推荐）。
# r ：以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
# rb ：以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
# r+ ：打开一个文件用于读写。文件指针将会放在文件的开头。
# rb+ ：以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
# w ：打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
# wb ：以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
# w+ ：打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
# wb+：以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
# a ：打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
# ab ：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
# a+ ：打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
# ab+：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
f = open("new_test.txt");
print(f.read());

# 所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
# memoryview(obj)
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1]) # 98
print(v[-1]) # 103
print(v[1:4]) # <memory at 0x000001CCF9F7C7C8>
print(v[1:4].tobytes()) # b'bce'

# 该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息
# dir([object])
# print(dir()) # 获得当前模块的属性列表
# 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']

# exec obj
exec ("""for i in range(5):
    print(i)""") # 换行时候必须采用4格缩进
# 0
# 1
# 2
# 3
# 4

# Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
# 基本语法是通过 {} 和 : 来代替以前的 % 。
print("{}{}".format("hello", "world"))
# 不设置指定位置，按默认顺序
print( "{1} {0} {1}".format("hello", "world")) # 设置指定位置
# 数字格式化
# 下表展示了 str.format() 格式化数字的多种方法：
# 3.1415926 {:.2f} 3.14 保留小数点后两位
# 3.1415926 {:+.2f} +3.14 带符号保留小数点后两位
# -1 {:+.2f} -1.00 带符号保留小数点后两位
# 2.71828 {:.0f} 3 不带小数
# 5 {:0>2d} 05 数字补零 (填充左边, 宽度为2)
# 5 {:x<4d} 5xxx 数字补x (填充右边, 宽度为4)
# 10 {:x<4d} 10xx 数字补x (填充右边, 宽度为4)
# 1000000 {:,} 1,000,000 以逗号分隔的数字格式
# 0.25 {:.2%} 25.00% 百分比格式
# 1000000000 {:.2e} 1.00e+09 指数记法
# 13 {:>10d} 13 右对齐 (默认, 宽度为10)
# 13 {:<10d} 13 左对齐 (宽度为10)
# 13 {:^10d} 13 中间对齐 (宽度为10)
# ^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
# + 表示在正数前显示 +，负数前显示 -；（空格）表示在正数前加空格
# b、d、o、x 分别是二进制、十进制、八进制、十六进制。
# 此外我们可以使用大括号{} 来转义大括号，如下实例：
# 实例
print("{} 对应的位置是{{1}}".format("runoob"))

# round( x [, n] )
# x -- 数值表达式。
# n -- 数值表达式，表示从小数点位数
print("round(80.23456, 2) :", round(80.23456, 2)) # 80.23
print("round(100.000056,3) :" , round(100.000056, 3)) # 100.0

# list.reverse()
yc =["1232", "sdw", "sda", "sdv","sdg"]
print(yc.reverse())
print(yc)

# range(stop)
# range(start, stop[, step])
for yc in range(2, 6, 2):
    print(yc) # 2 
    
    

__import__()--没太看明白了，看到了那句“Direct useof __import__() is rare”之后就没心看下去了
apply()、buffer()、coerce()、intern()---这些是过期的内置函数，故不说明