第五章 - 补充1(Python内置函数详解)
5.14 Python内置函数详解
Python给我们提供的内置函数一共是68个。一个函数是封装了一个功能，我们可以调用函数来完成复杂的程序。
5.14.1 进制的转换
bin()
bin() 返回一个整数 int 或者长整数 long int 的二进制表示。二进制0,1。
使用语法：
bin(x)
# x 为整数或者长整数
# 返回值为一个二进制的字符串，0b开头。
函数实例：
print(bin(10))
# '0b1010'
print(bin(20))
# '0b10100'
oct()
oct() 函数将一个整数转换成八进制字符串。八进制：0-7
使用语法：
oct(x)
# x 为整数
# 返回一个八进制的字符串，0o开头。
函数实例：
print(oct(10))
# 0o12
print(oct(20))
# 0o24
hex()
hex() 函数用于将一个指定数字转换为十六进制数。十六进制：0-9，a-f。
使用语法：
hex(x)
# x 为整数
# 返回值为一个十六进制数的字符串，0x开头。
函数实例：
print(hex(255))
# '0xff'
print(hex(-31))
# '-0x1f'
print(hex(15))
# '0xf'
二进制数转换成十进制数
由二进制数转换成十进制数的基本做法是，把二进制数首先写成加权系数展开式，然后按十进制加法规则求和。这种做法称为"按权相加"法。
例如把二进制数 110.11 转换成十进制数。
十进制数转换为二进制数
十进制数转换为二进制数时，由于整数和小数的转换方法不同，所以先将十进制数的整数部分和小数部分分别转换后，再加以合并。
- 十进制整数转换为二进制整数
十进制整数转换为二进制整数采用"除2取余，逆序排列"法。具体做法是：用2去除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为零时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。
例如把 (173)10 转换为二进制数。
2．十进制小数转换为二进制小数
十进制小数转换成二进制小数采用"乘2取整，顺序排列"法。具体做法是：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数 部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，或者达到所要求的精度为止。
然后把取出的整数部分按顺序排列起来，先取的整数作为二进制小数的高位有效位，后取的整数作为低位有效位。
例如把（0.8125）转换为二进制小数。
例：
（173.8125）10＝（ ）2
解：
在上个例子中得（173）10＝（10101101）2
得（0.8125）10＝（0.1101）2
把整数部分和小数部分合并得：
（173.8125）10＝（10101101.1101）2
十进制小数转换成二进制小数采用"乘2取整，顺序排列"法。具体做法是：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又 得到一个积，再将积的整数部分取出，如此进行，直到积中的整数部分为零，或者整数部分为1，此时0或1为二进制的最后一位。或者达到所要求的精度为止。
然后把取出的整数部分按顺序排列起来，先取的整数作为二进制小数的高位有效位，后取的整数作为低位有效位。
oct()函数
bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
使用语法：
bin(x)
# x 为整数或者长整数
# 返回值为一个字符串形式的二进制
函数实例：
print(bin(10))
# '0b1010'
print(bin(20))
# '0b10100'
5.14.2 数学运算
abs()
abs() 函数返回数字的绝对值。
使用语法：
abs(x)
# x 为数值表达式，可以是整数，浮点数，复数。
# 函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小。
函数实例：
print(abs(-10))
# 10
print(abs(20.10))
# 20.1
sum()
sum() 方法对系列进行求和计算。
使用语法：
sum(iterable[, start])
# iterable：可迭代对象，如：列表、元组、集合。
# start：指定相加的参数，如果没有设置这个值，默认为0。
# 返回计算结果
函数实例：
l1 = [1,2,3,4,5,6]
print(sum(l1)) # 21
print(sum((1,2,3,4,5),6)) # 21
min()
min() 方法返回给定参数的最小值，参数可以为序列。
使用语法：
min( x, y, z, .... )
# x -- 数值表达式。
# y -- 数值表达式。
# z -- 数值表达式。
# 返回给定参数的最小值。
函数实例：
print(min(20,21,3,44,5))
# 3
l1 = [2,1,3,4,5,66,3]
print(min(l1))
# 1
max()
max() 方法返回给定参数的最大值，参数可以为序列。
使用语法：
bin(x)
# x -- 数值表达式。
# y -- 数值表达式。
# z -- 数值表达式。
# 返回给定参数的最大值。
函数实例：
print(max(20,21,3,44,5))
# 44
l1 = [2,1,3,4,5,66,3]
print(max(l1))
# 66
另外min()与max()还有以下功能：
# 按照绝对值的大小，返回此序列最小值
ret = min([1,2,-5,],key=abs)
print(ret)
# 加key是可以加函数名，min自动会获取传入函数中的参数的每个元素，然后通过你设定的返回值比较大小，返回最小的传入的那个参数。
# 可以设置很多参数比较大小
print(min(1,2,-5,6,-3,key=lambda x:abs(x)))
# x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键
dic = {'a':3,'b':2,'c':1}
print(min(dic,key=lambda x:dic[x]))
# max一样操作
pow()
pow() 方法返回 x**y（x的y次方） 的值。
使用语法：
注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。
import math
pow(x, y[, z])
# 函数是计算x的y次方，如果z存在，则再对结果进行取模，其结果等效于pow(x,y) %z
函数实例：
import math
print(pow(100,2)) # 10000.0
print(pow(100,2)) # 10000
print(pow(100,2,4)) # 0
round()
round()方法返回浮点数x的四舍五入值。
使用语法：
round( x [, n] )
# x -- 数值表达式。
# n -- 数值表达式，表示从小数点位数。
# 返回浮点数x的四舍五入值。
函数实例：
# round(x[,n]) x为数字表达式，n为小数点位数(四舍六入)
print(round(52.345,2))
# 52.34
print(round(52.3*68.546,2)) # 3584.96
divmod()
divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
使用语法：
divmod(a, b)
# a: 数字
# b: 数字
函数实例：
print(divmod(10,3)) # (3, 1)
5.14.3 数据类型相关
- 数据类型转换
str()
str() 函数将对象转化为字符串类型。
使用语法：
str(object='')
# object对象
# 返回值一个对象的string格式
函数实例：
a = 12345
print(str(a))
# '12345'
list = [1,2,'a',3,'d','f']
print(str(list))
# '[1, 2, 'a', 3, 'd', 'f']'
int()
int() 函数用于将一个字符串或数字转换为整型。
使用语法：
int(x,base=10)
# x 为字符串或数字
# base 为进制数，默认十进制
# 返回整型数据
函数实例：
a = '1234' # str类型
print(int(a))
# 1234
print(int('12',16))
# 18
float()
float() 函数用于将整数和字符串转换成浮点数。
使用语法：
float(x)
# x 为整数或者字符串
# 返回浮点数
函数实例：
print(float(1))
# 1.0
print(float(-123.9))
# -123.9
bool()
bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。bool是int的子类；0与没有为False，1为True。
使用语法：
bool(x)
# x 要进行转换的参数
# 返回True或False
函数实例：
print(bool())
# False
print(bool(0))
# False
print(bool(1))
# True
print(bool(2))
# True
print(issubclass(bool, int)) # bool 是 int 子类
# True
list()
list() 方法用于将序列（元组，集合，字符串等）转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。集合和列表也是很相似的，区别在于集合不能有重复值。只有与列表结构相似的序列才能转换为列表，字典只能分别将他们的键和值转换成列表。
使用语法：
list(seq)
# seq 要转换为列表的元组或字符串。
# 返回列表
函数实例：
aTuple = (123, '张三', '李四', '王二麻')
list1 = list(aTuple)
print ("列表元素 : ", list1)
# 列表元素 : [123, '张三', '李四', '王二麻']
str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)
# 列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
# list还可以用来创建一个空列表
l1 = list()
print(l1)
# []
tuple()
tuple() 函数将可迭代系列（如列表）转换为元组。
使用语法：
tuple(iterable)
# iterable 要转换为元组的可迭代序列
# 返回元组
函数实例：
list1 = [123, '张三', '李四', '王二麻']
t1 = tuple(list1)
print (t1)
# (123, '张三', '李四', '王二麻')
# tuple()还可用来创建空元组
t2 = tuple()
print(t2)
# ()
dict()
dict() 函数用于创建一个字典。
使用语法：
dict(**kwarg)
dict(mapping, **kwarg)
dict(iterable, **kwarg)
# **kwargs -- 关键字。
# mapping -- 元素的容器，映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
# iterable -- 可迭代对象。
# 返回一个字典
函数实例：
dict1 = dict()# 创建空字典
print(dict1) # {}
dict2 = dict(a='a', b='b', t='t') # 传入关键字
print(dict2)
# {'a': 'a', 'b': 'b', 't': 't'}
dict3 = dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典
print(dict3)
# {'one': 1, 'two': 2, 'three': 3}
dict4 = dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典
print(dict4)
# {'one': 1, 'two': 2, 'three': 3}
# 只使用关键字参数创建字典
numbers = dict(x=5, y=0)
print('numbers =', numbers)
# numbers = {'x': 5, 'y': 0}
print(type(numbers))
# <class 'dict'>
# 创建空字典
empty = dict()
print('empty =', empty)
# empty = {}
print(type(empty))
# <class 'dict'>
# 使用可迭代对象创建字典
# 没有设置关键字参数
numbers1 = dict([('x', 5), ('y', -5)])
print('numbers1 =',numbers1)
# numbers1 = {'x': 5, 'y': -5}
# 设置关键字参数
numbers2 = dict([('x', 5), ('y', -5)], z=8)
print('numbers2 =',numbers2)
# numbers2 = {'x': 5, 'y': -5, 'z': 8}
# zip() 创建可迭代对象
numbers3 = dict(dict(zip(['x', 'y', 'z'], [1, 2, 3])))
print('numbers3 =',numbers3)
# numbers3 = {'x': 1, 'y': 2, 'z': 3}
# 使用映射来创建字典
# 映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
numbers1 = dict({'x': 4, 'y': 5})
print('numbers1 =',numbers1)
# numbers1 = {'x': 4, 'y': 5}
# 以下代码不需要使用 dict()
numbers2 = {'x': 4, 'y': 5}
print('numbers2 =',numbers2)
# numbers2 = {'x': 4, 'y': 5}
# 关键字参数会被传递
numbers3 = dict({'x': 4, 'y': 5}, z=8)
print('numbers3 =',numbers3)
# numbers3 = {'x': 4, 'y': 5, 'z': 8}
set()
set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
使用语法：
set(iterable)
# iterable：可迭代对象对象
# 返回新的集合对象
函数实例：
# set()
x = set('runoob')
y = set('google')
print(x, y)
# {'b', 'u', 'r', 'n', 'o'} {'l', 'g', 'e', 'o'} # 重复的被删除
print(x & y) # 交集
# {'o'}
print(x | y) # 并集
# {'e', 'l', 'r', 'g', 'b', 'u', 'n', 'o'}
print(x - y) # 差集
# {'b', 'r', 'u', 'n'}
complex()
complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
使用语法：
complex([real[, imag]])
# real：int, long, float或字符串；
# imag：int, long, float；
# 返回值一个复数
函数实例：
# complex()
print(complex(1, 2))
# (1 + 2j)
print(complex(1)) # 数字
# (1 + 0j)
print(complex("1")) # 当做字符串处理
# (1 + 0j)
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
print(complex("1+2j"))
# (1 + 2j)
- 类型操作
len()
len() 方法返回对象（字符、列表、元组等）长度或项目个数。
使用语法：
len(s)
# 对象
# 返回对象长度
函数实例：
# len()
str = 'hello world!'
print(len(str)) # 12
l = [1,2,3,4,5]
print(len(l)) # 5
type()
type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
使用语法：
type(object)
type(name, bases, dict)
# name -- 类的名称。
# bases -- 基类的元组。
# dict -- 字典，类内定义的命名空间变量。
# 一个参数返回对象类型, 三个参数，返回新的类型对象。
函数实例：
# type()
str = 'hello'
print(type(str)) # <class 'str'>
l = [1,2,3,4]
print(type(l)) # <class 'list'>
# 三个参数
class X(object):
a = 1
X = type('X', (object,), dict(a=1)) # 产生一个新的类型 X
print(X)
# <class '__main__.X'>
isinstance()
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
使用语法：
isinstance(object, classinfo)
# object -- 实例对象。
# classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。
# 如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。
函数实例：
# isinstance()
a = 2
print(isinstance (a,int)) # True
print(isinstance (a,str)) # False
# 是元组中的一个返回 True
print(isinstance (a,(str,int,list))) # True
isinstance() 与 type() 区别：
- type() 不会认为子类是一种父类类型，不考虑继承关系。
- isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
chr()
chr() 用一个范围在 range（256）内的（就是0～255）整数作参数,返回值是当前整数对应的 ASCII 字符。
使用语法：
chr(i)
# i 可以是 10 进制也可以是 16 进制的形式的数字，数字范围为 0 到 1,114,111 (16 进制为0x10FFFF)。
# 返回值是当前整数对应的 ASCII 字符。
函数实例：
print(chr(0x30), chr(0x31), chr(0x61)) # 十六进制
# 0 1 a
print(chr(48), chr(49), chr(97)) # 十进制
# 0 1 a
ord()
ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。
使用语法：
ord(c)
# c -- 字符。
# 返回值是对应的十进制整数。
函数实例：
print(ord('a'))
# 97
pritn(ord('€'))
# 8364
repr()
repr() 函数将对象转化为供解释器读取的形式。
使用语法：
repr(object)
# object -- 对象。
# 返回一个对象的 string 格式。
函数实例：
s = 'hello world'
print(repr(s))
# 'hello world'
dict = {'name': '张三', 'age': 18};
print(repr(dict))
# {'name': '张三', 'age': 18}
compile()
compile() 函数将一个字符串编译为字节代码。
使用语法：
compile(source, filename, mode[, flags[, dont_inherit]])
# source -- 字符串或者AST（Abstract Syntax Trees）对象。。
# filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
# mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
# flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
# flags和dont_inherit是用来控制编译源码时的标志
# 返回表达式执行结果。
函数实例：
str = "for i in range(0,10): print(i)"
c = compile(str,'','exec') # 编译为字节代码对象
print(exex(c))
str = "3 * 4 + 5"
a = compile(str,'','eval')
print(eval(a))
# 17
bytes()
bytes() 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。
使用语法：
bytes([source[, encoding[, errors]]])
# 如果 source 为整数，则返回一个长度为 source 的初始化数组；
# 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
# 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
# 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
# 如果没有输入任何参数，默认就是初始化数组为0个元素。
# 返回一个新的 bytes 对象。
函数实例：
bytes()
a = bytes([1,2,3,4])
print(a)
# b'\x01\x02\x03\x04'
print(type(a))
# <class 'bytes'>
a = bytes('hello','ascii')
print(a)
# b'hello'
print(type(a))
# <class 'bytes'>
ascii()
ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。 生成字符串类似 Python2 版本中 repr() 函数的返回值。
使用语法：
ascii(object)
# objext 对象
# 返回字符串
函数实例：
# ascii()
print(ascii('hello'))
# 'hello'
enumerate()
enumerate() 枚举类型，用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
同时列出数据和数据下标，一般用在 for 循环当中。
使用语法：
enumerate(sequence, [start=0])
# sequence -- 一个序列、迭代器或其他支持迭代对象。
# start -- 下标起始位置。
# 返回 enumerate(枚举) 对象。
函数实例：
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
# 下标从 1 开始
print(list(enumerate(seasons, start=1)))
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
# for循环使用enumerate
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
print(i, element)
format()
str.format()格式化字符串的函数 ，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的%。
format() 函数可以接受不限个参数，位置可以不按顺序。
函数实例：
# 不设置指定位置，按默认顺序
print("{} {}".format("hello", "world"))
# 'hello world'
# 设置指定位置
print("{0} {1}".format("hello", "world"))
'hello world'
# 设置指定位置
print("{1} {0} {1}".format("hello", "world"))
# 'world hello world'
# 设置参数
print("姓名：{name}, 性别： {sex}".format(name="张三", sex="男"))
# 通过字典设置参数
site = {"name": "张三", "sex": "男"}
print("姓名：{name}, 性别： {sex}".format(**site))
# 通过列表索引设置参数
my_list = ['张三', '男']
print("姓名：{0[0]}, 性别： {0[1]}".format(my_list)) # "0" 是必须的
数字格式化
print("{:.2f}".format(3.1415926))
# 3.14
| 数字 | 格式 | 输出 | 描述 |
|---|---|---|---|
| 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) |
| 11 | ‘{:b}’.format(11) ‘{:d}’.format(11) ‘{: o}’.format(11) ‘{:x}’.format(11) ‘{:#x}’.format(11) ‘{:#X}’.format(11) | 1011 11 13 b 0xb 0XB | 进制 |
^,<,> 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
此外我们可以使用大括号 {} 来转义大括号，{{}}
bytearray()
bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
使用语法：
bytearray([source[, encoding[, errors]]])
# 如果 source 为整数，则返回一个长度为 source 的初始化数组；
# 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
# 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
# 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
# 如果没有输入任何参数，默认就是初始化数组为0个元素。
# 返回新字节数组。
函数实例：
# 如果没有输入任何参数，默认就是初始化数组为0个元素。
print(bytearray())
# bytearray(b'')
# 可迭代类型，则元素必须为[0 ,255] 中的整数；
print(bytearray([1,2,3]))
# bytearray(b'\x01\x02\x03')
# 字符串则按照指定的 encoding 将字符串转换为字节序列；
print(bytearray('hello', 'utf-8'))
# bytearray(b'hello')
eval()
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
使用语法：
eval(expression[, globals[, locals]])
# expression：表达式。
# globals：变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
# locals：变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
# 返回表达式计算结果。
函数实例：
a = '1+2+3+4'
print(eval(a)) # 10
n = 5
print(eval('2 * n')) # 10
exec()
exec() 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。
使用语法：
exec(object[, globals[, locals]])
# object：必选参数，表示需要被指定的 Python 代码。它必须是字符串或 code 对象。如果 object 是一个字符串，该字符串会先被解析为一组 Python 语句，然后再执行（除非发生语法错误）。如果 object 是一个 code 对象，那么它只是被简单的执行。
# globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
# locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与 globals 相同的值。
# exec 返回值永远为 None。
函数实例：
exec("print('hello world')") # hello world
# execfile() 函数可以用来执行一个文件。
execfile('hello.py')
frozenset()
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
使用语法：
frozenset([iterable])
# iterable -- 可迭代的对象，比如列表、字典、元组等等。
# 返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
函数实例：
# 生成一个新的不可变集合
a = frozenset(range(10))
print(a)
# frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
# 创建不可变集合
b = frozenset('hello')
print(b)
# frozenset({'e', 'l', 'o', 'h'})
3、作用域相关
globals()
globals() 函数会以字典类型返回当前位置的全部全局变量。
使用语法：
globals()
# 无参数
# 返回全局变量的字典
函数实例：
print(globals())
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7f8b4542c630>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '.code.tio', '__cached__': None}
locals()
locals() 函数会以字典类型返回当前位置的全部局部变量。
对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。
使用语法：
locals()
# 无参数
# 返回字典类型的局部变量
函数实例：
# 函数中有两个局部变量：args、a
def school(arg):
a = 1
print(locals())
school(2)
# {'a': 1, 'arg': 2}
4、面向对象相关
object()
object类是所有类的父类。
property()
property() 函数的作用是在新式类中返回属性值。
使用语法：
property([fget[, fset[, fdel[, doc]]]])
# fget -- 获取属性值的函数
# fset -- 设置属性值的函数
# fdel -- 删除属性值函数
# doc -- 属性描述信息
# 返回新式类属性。
函数实例：
# 定义一个可控属性值 x
class C(object):
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
c = C()
如果 c 是C 的实例化, c.x 将触发 getter,c.x = value 将触发 setter ， del c.x 触发 deleter。
如果给定 doc 参数，其将成为这个属性值的 docstring，否则 property 函数就会复制 fget 函数的 docstring（如果有的话）。
将 property 函数用作装饰器可以很方便的创建只读属性：
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
上面的代码将 voltage() 方法转化成同名只读属性的 getter 方法。
property 的 getter,setter 和 deleter 方法同样可以用作装饰器：
class C(object):
def __init__(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
# 注意这些额外函数的名字和 property 下的一样，例如这里的 x。
classmethod()
classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
使用语法：
classmethod
# 无参数
# 返回函数的类方法
函数实例：
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
delattr()
delattr 函数用于删除属性。delattr(x, 'foobar') 相等于 del x.foobar。
使用语法：
delattr(object, name)
# object：对象。
# name：必须是对象的属性。
# 无返回值
函数实例：
class A:
x = 10
y = -5
z = 0
a1 = A()
print('x = ',a1.x)
print('y = ',a1.y)
print('z = ',a1.z)
delattr(A, 'z')
print('--删除 z 属性后--')
print('x = ',a1.x)
print('y = ',a1.y)
# 触发错误
print('z = ',a1.z)
getattr()
getattr() 函数用于返回一个对象属性值。
使用语法：
getattr(object, name[, default])
# object -- 对象。
# name -- 字符串，对象属性。
# default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
# 返回对象属性值。
函数实例：
class A(object):
bar = 1
a = A()
# 获取属性 bar 值
print(getattr(a,'bar'))
# 1
# 属性 bar2 不存在，触发异常
print(getattr(a,'bar2'))
# 属性 bar2 不存在，但设置了默认值
print(getattr(a,'bar2', 3))
# 3
setattr()
setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
使用语法：
setattr(object, name, value)
# object -- 对象。
# name -- 字符串，对象属性。
# value -- 属性值。
# 无返回值
函数实例：
# 对已存在的属性进行赋值：
class A(object):
bar = 1
a = A()
# 获取属性 bar 值
print(getattr(a, 'bar'))
# 1
# 设置属性 bar 值
setattr(a, 'bar', 5)
print(a.bar)
# 5
如果属性不存在会创建一个新的对象属性，并对属性赋值：
class A():
name = "张三"
a = A()
setattr(a, "age", 18)
print(a.age)
# 18
hasattr()
hasattr() 函数用于判断对象是否包含对应的属性。
使用语法：
hasattr(object, name)
# object -- 对象。
# name -- 字符串，属性名。
# 如果对象有该属性返回 True，否则返回 False。
函数实例：
class A:
x = 10
y = -5
z = 0
a1 = A()
print(hasattr(a1, 'x'))
# True
print(hasattr(a1, 'y'))
# True
print(hasattr(a1, 'z'))
# True
print(hasattr(a1, 'no')) # 没有该属性
# True
issubclass()
issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
使用语法：
issubclass(class, classinfo)
# class -- 类。
# classinfo -- 类。
# 如果 class 是 classinfo 的子类返回 True，否则返回 False。
函数实例：
class A:
print('父类')
class B(A):
print('子类')
print(issubclass(B,A)) # 返回 True
memoryview()
memoryview() 函数返回给定参数的内存查看对象(memory view)。
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
使用语法：
memoryview(obj)
# obj -- 对象
# 返回元组列表。
函数实例：
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])
# 98
print(v[-1])
# 103
print(v[1:4])
# <memory at 0x10f543a08>
print(v[1:4].tobytes())
# b'bce'
super()
super() 函数是用于调用父类(超类)的一个方法。
super() 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
使用语法：
super(type[, object-or-type])
# type -- 类。
# object-or-type -- 类，一般是 self
# 无返回值
函数实例：
class FooParent(object):
def __init__(self):
self.parent = 'I\'m the parent.'
print ('Parent')
def bar(self,message):
print ("%s from Parent" % message)
class FooChild(FooParent):
def __init__(self):
# super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类 FooChild 的对象转换为类 FooParent 的对象
super(FooChild,self).__init__()
print ('Child')
def bar(self,message):
super(FooChild, self).bar(message)
print ('Child bar fuction')
print (self.parent)
if __name__ == '__main__':
fooChild = FooChild()
fooChild.bar('HelloWorld')
# 执行结果：
# Parent
# Child
# HelloWorld from Parent
# Child bar fuction
# I'm the parent.
staticmethod()
staticmethod 返回函数的静态方法。
该方法不强制要求传递参数，如下声明一个静态方法：
class C(object):
@staticmethod
def f(arg1, arg2, ...):
...
以上实例声明了静态方法 f，从而可以实现实例化使用 C().f()，当然也可以不实例化调用该方法 C.f()。
使用语法：
staticmethod(function)
# 无参数
# 无返回值
函数实例：
class C(object):
@staticmethod
def f():
print('runoob');
C.f(); # 静态方法无需实例化
cobj = C()
cobj.f() # 也可以实例化后调用
vars()
vars() 函数返回对象object的属性和属性值的字典对象。
使用语法：
vars([object])
# object -- 对象
# 返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。
函数实例：
print(vars())
# {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
class Runoob:
a = 1
print(vars(Runoob))
# {'a': 1, '__module__': '__main__', '__doc__': None}
runoob = Runoob()
print(vars(runoob))
# {}
5、迭代器/生成器相关
iter()
iter() 函数用来生成迭代器。
使用语法：
iter(object[, sentinel])
# object -- 支持迭代的集合对象。
# sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
# 迭代器对象。
函数实例：
lst = [1, 2, 3]
for i in iter(lst):
print(i)
all()
all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
元素除了是 0、空、None、False 外都算 True。
使用语法：
all(iterable)
# iterable -- 元组或列表。
# 如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；
# 注意：空元组、空列表返回值为True，这里要特别注意。
函数实例：
# 列表list，元素都不为空或0
print(all(['a', 'b', 'c', 'd']))
# True
# 列表list，存在一个为空的元素
print(all(['a', 'b', '', 'd']))
# False
# 列表list，存在一个为0的元素
print(all([0,1,2,3]))
# False
# 元组tuple，元素都不为空或0
print(all(('a', 'b', 'c', 'd')))
# True
# 元组tuple，存在一个为空的元素
print(all(('a', 'b', '', 'd')))
# False
# 元组tuple，存在一个为0的元素
print(all((0, 1, 2, 3)))
# False
# 空列表
print(all([]))
# True
# 空元组
print(all(()))
# True
any()
any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
元素除了是 0、空、FALSE 外都算 TRUE。
使用语法：
any(iterable)
# iterable -- 元组或列表。
# 如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
函数实例：
# 列表list，元素都不为空或0
print(any(['a', 'b', 'c', 'd']))
# True
# 列表list，存在一个为空的元素
print(any(['a', 'b', '', 'd']))
# True
# 列表list,元素全为0,'',false
print(any([0, '', False]))
# False
# 元组tuple，元素都不为空或0
print(any(('a', 'b', 'c', 'd')))
# True
# 元组tuple，存在一个为空的元素
print(any(('a', 'b', '', 'd')))
# True
# 元组tuple，元素全为0,'',false
print(any((0, '', False)))
# False
# 空列表
print(any([]))
# False
# 空元组
print(any(()))
# False
next()
next() 返回迭代器的下一个项目。
next() 函数要和生成迭代器的 iter() 函数一起使用。
使用语法：
next(iterable[, default])
# iterable -- 可迭代对象
# default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
# 返回下一个项目。
函数实例：
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
while True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration:
# 遇到StopIteration就退出循环
break
range()
range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。
Python3 list() 函数是对象迭代器，可以把 range() 返回的可迭代对象转为一个列表，返回的变量类型为列表。
Python2 range() 函数返回的是列表。
使用语法：
range(stop)
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)
函数实例：
# 查看range的类型
a = range(10)
print(type(a))
# <class 'range'>
# 使用list函数可以返回一个列表
l1 = list(a)
print(l1)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 如果只提供一个参数，它将生成一个从 0 开始的整数序列，参数为结束值，步长默认为 1：
for number in range(6):
print(number)
# 如果只提供开始值和结束值，那么步长默认为 1：
for number in range(1, 6):
print(number)
# 可以指定步长，以便每次增加不同的数量：
for number in range(1, 6, 2):
print(number)
# 注意：结束值 6 不包括在内。
# 另外，我们可以使用负数作为步长，以便从结束值倒序生成序列：
for number in range(6, 1, -1):
print(number)
# 注意：如果使用负数作为步长，则开始值必须大于结束值。
# 如果您只需要生成一个整数序列，并不需要使用 for 循环遍历它，那么您可以将 range() 函数的返回值转换为列表或元组，例如：
# 以下生成一个整数列表：
list1 = list(range(1, 6))
print(list1)
# [1, 2, 3, 4, 5]
# 以下生成一个整数元组：
tup1 = tuple(range(1, 6))
print(tup1)
# (1, 2, 3, 4, 5)
filter()
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
使用语法：
filter(function, iterable)
# function -- 判断函数。
# iterable -- 可迭代对象。
# 返回一个迭代器对象
函数实例：
# 过滤出列表中的所有奇数：
def is_odd(n):
return n % 2 == 1
lsit1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
tmplist = filter(is_odd,lsit1)
newlist = list(tmplist)
print(newlist)
# [1, 3, 5, 7, 9]
# 过滤出1~100中平方根是整数的数：
import math
def is_sqr(x):
return math.sqrt(x) % 1 == 0
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
print(newlist)
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
reversed()
reversed() 函数返回一个反转的迭代器。
使用语法：
reversed(seq)
# seq -- 要转换的序列，可以是 tuple, string, list 或 range。
# 返回一个反转的迭代器。
函数实例：
# 字符串
str1 = 'hello word'
print(list(reversed(str1)))
# ['d', 'r', 'o', 'w', ' ', 'o', 'l', 'l', 'e', 'h']
# 元组
tup1 = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(tup1)))
# ['b', 'o', 'o', 'n', 'u', 'R']
# range
a = range(5, 9)
print(list(reversed(a)))
# [8, 7, 6, 5]
# 列表
lst1 = [1, 2, 4, 3, 5]
print(list(reversed(lst1)))
# [5, 3, 4, 2, 1]
sorted()
sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别：
- sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
- list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
使用语法：
sorted(iterable, key=None, reverse=False)
# iterable -- 可迭代对象。
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
# 返回重新排序的列表。
函数实例：
# 简单排序,默认为升序
lst1 = [5, 2, 3, 1, 4]
sorted(lst1)
# [1, 2, 3, 4, 5]
# 使用 list 的 list.sort() 方法。这个方法会修改原始的 list（返回值为None）。
# 通常这个方法不如sorted()方便-如果你不需要原始的 list，list.sort()方法效率会稍微高一些。
lst1 =[5,2,3,1,4]
print(lst1.sort())
# [1,2,3,4,5]
# 另一个区别在于list.sort() 方法只为 list 定义。而 sorted() 函数可以接收任何的 iterable。
print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}))
# [1, 2, 3, 4, 5]
# 利用key进行倒序排序
lst1 = [5, 0, 6, 1, 2, 7, 3, 4]
ret_lst1 = sorted(lst1, key=lambda x: x*-1)
print(result_list)
# [7, 6, 5, 4, 3, 2, 1, 0]
# 要进行反向排序，也通过传入第三个参数 reverse=True：
lst2 = [5, 0, 6, 1, 2, 7, 3, 4]
ret_lst2 = sorted(lst2, reverse=True)
# [7, 6, 5, 4, 3, 2, 1, 0]
# 以下是个更复杂的实例，对奖牌榜就行排序，数据里面包含了15个国家的金、银、铜数据，使用 \n 作为分隔符：
s = "德国 10 11 16\n意大利 10 10 20\n荷兰 10 12 14\n法国 10 12 11\n英国 22 21 22\n中国 38 32 18\n日本 27 14 17\n美国 39 41 33\n俄罗斯奥委会 20 28 23\n澳大利亚 17 7 22\n匈牙利 6 7 7\n加拿大 7 6 11\n古巴 7 3 5\n巴西 7 6 8\n新西兰 7 6 7"
stodata = s.split('\n',-1)
# 使用sorted
para = {}
for line in range(len(stodata)):
# 每一行数据
data = stodata[line].split(' ')
print(data)
# 组装数据结构para={'China': [], 'Russia': []}
para[data[0]] = [int('-' + i) for i in data[1:]]
# 开始排序(x[1]代表奖牌数目, x[0]代表国家)
new_para = sorted(para.items(), key=lambda x: (x[1], x[0]))
print()
c=[]
for i in new_para:
c.append((i[0]))
for j in range(15):
print(f"{(j+1):2d} {c[j]}")
zip()
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
使用语法：
zip([iterable, ...])
# iterabl -- 一个或多个迭代器;
# 返回一个对象。
函数实例：
a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
# 返回一个对象
zipped = zip(a,b)
print(zipped)
# <zip object at 0x103abc288>
# list() 转换为列表
print(list(zipped))
# [(1, 4), (2, 5), (3, 6)]
# 元素个数与最短的列表一致
print(list(zip(a,c)))
# [(1, 4), (2, 5), (3, 6)]
# 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
a1, a2 = zip(*zip(a,b))
print(list(a1))
# [1, 2, 3]
print(list(a2))
# [4, 5, 6]
6、其他
callable()
callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。
使用语法：
callable(object)
# object -- 对象
# 可调用返回 True，否则返回 False。
函数实例：
print(callable(0))
# False
print(callable("runoob"))
# False
def add(a, b):
return a + b
# 函数返回 True
print(callable(add))
# True
# 类
class A:
def method(self):
return 0
# 类返回 True
print(callable(A))
# True
# 对象中没有实现 __call__, 返回 False
a = A()
print(callable(a))
# False
class B:
def __call__(self):
return 0
print(callable(B))
# True
# 实现 __call__, 返回 True
b = B()
print(callable(b))
# True
dir()
dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
使用语法：
dir([object])
# object -- 对象、变量、类型。
# 返回模块的属性列表。
函数实例：
# 获得当前模块的属性列表
print(dir())
# ['__annotations__', '__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']
hash()
hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
使用语法：
hash(object)
# object -- 对象；
# 返回对象的哈希值。
函数实例：
# 字符串
print(hash('test'))
# 3429482673007749228
# 数字
print(hash(123))
# 123
# 集合
print(hash(str([1,2,3])))
# 5504680614381519865
# 字典
print(hash(str(sorted({'1':1}))))
# 4421465594309905042
help()
help() 函数用于查看函数或模块用途的详细说明。
使用语法：
help([object])
# object -- 对象；
# 返回对象帮助信息。
函数实例：
# 查看 sys 模块的帮助
help('sys')
# 查看 str 数据类型的帮助
help('str')
# 查看列表 list 帮助信息
help(list)
# 显示list的append方法的帮助
help(list.append)
id()
id() 函数返回对象的唯一标识符，标识符是一个整数。
CPython 中 id() 函数用于获取对象的内存地址。
使用语法：
id([object])
# object -- 对象。
# 返回对象的内存地址。
函数实例：
a = 1
print(id(a))
# 139928603973216
b = 'hello world'
print(id(b))
# 139928580383152
lst = [1,2,3,4]
print(id(lst))
# 140113043727816
print()
print() 方法用于打印输出，最常见的一个函数。
使用语法：
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
# objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
# sep -- 用来间隔多个对象，默认值是一个空格。
# end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
# file -- 要写入的文件对象。
# flush -- 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。
# 无返回值。
函数实例：
print(1)
# 1
print("Hello World")
# Hello World
a = 1
b = '张三'
print(a,b)
# 1 张三
print("aaa""bbb")
# aaabbb
print("aaa","bbb")
# aaa bbb
# 设置间隔符
print("hello","我是","张三",sep="，")
# hello，我是，张三
# 使用 flush 参数生成一个 Loading 的效果：
import time
print("---RUNOOB EXAMPLE ： Loading 效果---")
print("Loading",end = "")
for i in range(20):
print(".",end = '',flush = True)
time.sleep(0.5)
input()
input() 函数接受一个标准输入数据，返回为 string 类型。
使用语法：
input([prompt])
# prompt: 提示信息
# 返回一个字符串
函数实例：
a = input("input:")
# input:123 # 输入整数
print(type(a))
# <class 'str'>
# 字符串
a = input("input:")
# input:张三 # 正确，字符串表达式
print(type(a))
# <class 'str'> # 字符串
# input() 接收多个值
#输入三角形的三边长
a,b,c = (input("请输入三角形三边的长：").split())
a= int(a)
b= int(b)
c= int(c)
#计算三角形的半周长p
p=(a+b+c)/2
#计算三角形的面积s
s=(p*(p-a)*(p-b)*(p-c))**0.5
#输出三角形的面积
print("三角形面积为：",format(s,'.2f'))
map()
map() 函数会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
使用语法：
map(function, iterable, ...)
# function -- 函数
# iterable -- 一个或多个序列
# 返回一个迭代器。
函数实例：
def square(x) : # 计算平方数
return x ** 2
# 计算列表各个元素的平方
print(map(square, [1,2,3,4,5]))
# <map object at 0x100d3d550> # 返回迭代器
# 使用 list() 转换为列表
print(list(map(square, [1,2,3,4,5])))
# [1, 4, 9, 16, 25]
# 使用 lambda 匿名函数
print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])))
# [1, 4, 9, 16, 25]
open()
open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
注意：使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。
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:
mode 参数有：
| 模式 | 描述 |
|---|---|
| t | 文本模式 (默认)。 |
| x | 写模式，新建一个文件，如果该文件已存在则会报错。 |
| b | 二进制模式。 |
| + | 打开一个文件进行更新(可读可写)。 |
| U | 通用换行模式（不推荐）。 |
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
默认为文本模式，如果要以二进制模式打开，加上 b 。
函数实例：
f = open('test.txt')
f.read()
# 与with连用
with open('test.txt','a') as f:
f.read()
*详细内容见Python文件章节
slice()
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
使用语法：
slice(stop)
slice(start, stop[, step])
# start -- 起始位置
# stop -- 结束位置
# step -- 间距
# 返回一个切片对象。
函数实例：
myslice = slice(5) # 设置截取5个元素的切片
print(myslice)
# slice(None, 5, None)
arr = range(10)
print(arr)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
arr[myslice] # 截取 5 个元素
# [0, 1, 2, 3, 4]
__import__()
__import__() 函数用于动态加载类和函数 。
如果一个模块经常变化就可以使用 __import__() 来动态载入。
使用语法：
__import__(name[, globals[, locals[, fromlist[, level]]]])
# name -- 模块名
# 返回元组列表。
函数实例：
# a.py 文件代码：
import os
print ('在 a.py 文件中 %s' % id(os))
# test.py 文件代码：
import sys
__import__('a') # 导入 a.py 模块
函数实例：
def square(x) : # 计算平方数
return x ** 2
# 计算列表各个元素的平方
print(map(square, [1,2,3,4,5]))
# <map object at 0x100d3d550> # 返回迭代器
# 使用 list() 转换为列表
print(list(map(square, [1,2,3,4,5])))
# [1, 4, 9, 16, 25]
# 使用 lambda 匿名函数
print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])))
# [1, 4, 9, 16, 25]
open()
open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
注意：使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。
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:
mode 参数有：
| 模式 | 描述 |
|---|---|
| t | 文本模式 (默认)。 |
| x | 写模式，新建一个文件，如果该文件已存在则会报错。 |
| b | 二进制模式。 |
| + | 打开一个文件进行更新(可读可写)。 |
| U | 通用换行模式（不推荐）。 |
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
默认为文本模式，如果要以二进制模式打开，加上 b 。
函数实例：
f = open('test.txt')
f.read()
# 与with连用
with open('test.txt','a') as f:
f.read()
*详细内容见Python文件章节
slice()
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
使用语法：
slice(stop)
slice(start, stop[, step])
# start -- 起始位置
# stop -- 结束位置
# step -- 间距
# 返回一个切片对象。
函数实例：
myslice = slice(5) # 设置截取5个元素的切片
print(myslice)
# slice(None, 5, None)
arr = range(10)
print(arr)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
arr[myslice] # 截取 5 个元素
# [0, 1, 2, 3, 4]
__import__()
__import__() 函数用于动态加载类和函数 。
如果一个模块经常变化就可以使用 __import__() 来动态载入。
使用语法：
__import__(name[, globals[, locals[, fromlist[, level]]]])
# name -- 模块名
# 返回元组列表。
函数实例：
# a.py 文件代码：
import os
print ('在 a.py 文件中 %s' % id(os))
# test.py 文件代码：
import sys
__import__('a') # 导入 a.py 模块
3418
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
