目录
input()函数--接收一个标准输入数据,返回为string类型。
setattr()函数--用于设置属性值,该属性不一定是存在的
all()函数--用于判断给定的可迭代参数iterable中的所有元素是否都为True,返回True否则返回False
slice()函数-- 实现切片对象,主要用在切片操作函数里的参数传递。
any()函数--用于判断给定的可迭代参数 iterable 是否全部为 False,则返回 False,如果有一个为 True,则返回 True
enumerate()函数--将一个可便利的数据对象(如列表、元组或者字符串)组合为一个索引序列,同时列出数据和下表
eval()函数--用来执行一个字符串表达式,并返回表达式的值
bool()函数--用于将给定参数类型转换为布尔类型,如果没有参数,返回False
exec()函数--执行储存在字符串或文件中的 Python 语句
isinstantce()函数--来判断一个对象是否是一个已知的类型,类似 type()。
ord()函数--以一个字符串(Unicode 字符)作为参数,返回对应的 ASCII 数值
filter()函数--用于过滤序列,过滤掉不符合条件的元素,返回一个迭代器对象。
issubclass()函数--用于判断参数class是否是类型参数classinfo的子类型
len()方法--返回对象(字符,列表,元组等) 长度或项目个数
frozenset()函数--返回一个冻结的集合,冻结后集合不能在添加或删除任何元素。
var()函数--返回对象object的属性和属性值的字典对象
locals() 函数--以字典类型返回当前位置的全部局部变量
globals()函数--会以字典类型返回当前位置的全部全局变量
complex()函数--用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数
hasattr()函数-- 用于判断对象是否包含对应的属性。
round()函数--返回浮点数 x 的四舍五入值,准确的说保留值将保留到离上一位更近的一端
hash()函数--用于获取取一个(字符串或者数值等)的哈希值
set()函数--创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。
abs()函数--返回数字的绝对值
语法:abs(x) # x--数值
返回值:函数返回x(数字)的绝对值
示例:
print("abs(-45):", abs(-45))
print("abs(45):", abs(45))
运行结果:
divomd()函数--返回一个包含商余数的元组
语法:divomd(a, b) # a, b 都为数字(非复数)
- 如果参数a与b都为整数,函数返回的结果相当于(a // b, a % b)。
- 如果其中一个参数为浮点数时,函数返回的结果相当于(q, a%b),q通常是math.floor(a/b),但也有可能是1
- 如果a%b的求余结果部位0,则余数的正负符号跟参数b是一样的。
实例:
print("divmod(7, 2):", divmod(7, 2))
print("divmod(8, 2)", divmod(8, 2))
运行结果:
input()函数--接收一个标准输入数据,返回为string类型。
语法:input([prompt]) #prompt:提示信息
实例:
name = input("请输入一个名字:")
print("我接受到了你的名字:", name, type(name))
运行结果:
dict()函数--用于创建一个字典
语法:
class dict(**kwarg) class dict(mapping, **kwarg) class dict(iterable, **kwarg)
参数:
**kwarge -- 关键字
mapping--元素容器,映射类型(Mapping Type) 是一种关联式的容器类型,它储存了
对象与对象之间的关系。
iterable--可迭代的对象、
返回值:返回一个字典。
实例:
dict_test = dict(a='a', b='b', c='c')
print("dict_test:", dict_test, type(dict_test))
dict_test2 = dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典
print("dict_test2:", dict_test2, type(dict_test2))
dict_test3 = dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典
print("dict_test3:", dict_test3, type(dict_test3))
运行结果:
help()函数--用于查看函数或者模块用途的详细说明
语法:help([object]) # objecr:对象
返回值:返回对象的帮助信息
实例:
help(list)
运行结果:
min()函数--返回给定参数的最小值,参数可以为序列
语法:min(x, y, z, ......) # x, y, z 都为数值表达式
返回值:给定参数的最小值
实例:
print("min(80, 100, 1000) : ", min(80, 100, 1000))
print("min(-20, 100, 400) : ", min(-20, 100, 400))
list1 = [2, 3, 1, -5, 10, -1]
print("min(list1):", min(list1))
运行结果:
setattr()函数--用于设置属性值,该属性不一定是存在的
语法:setattr(object, name, value)
参数:
- object:对象
- name:字符串
- value:属性值
返回值:无
实例:
class A(object):
bar = 1
a = A()
print(getattr(a, 'bar'))
setattr(a, 'bar', 5)
print(a.bar)
print("="*10)
class B():
name = "runoob"
b = B()
setattr(b, "age", 10)
print(b.age, b.name)
运行结果
all()函数--用于判断给定的可迭代参数iterable中的所有元素是否都为True,返回True否则返回False
注意:除元素0,空,None,False外都算是True
语法:all(iterable) # iterable :元组或者列表
返回值:
所有元素都为Ture则返回True,否则返回False
实例:
print(all(['a', 'b', 'c'])) # 列表list,元素都不为空或0
print(all([])) # 空列表
print(all(())) # 空元组
print(all((0, 1, 3, 5, 10))) # 元组tuple,存在一个为空的元素
print(all(('a', 'g', ''))) # 元组tuple,存在一个为空的元素
运行结果:
dir()函数
描述:函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。
语法:dir([object]) # object:对象、变量、类型
返回值:返回模块的属性列表
实例:
print(dir()) # 获取当前模块的属性列表
print(dir([])) # 查看列表的方法
运行结果:
hex()函数--将一个指定数字转换为16进制数。
语法:hex(x) # x:一个整数
返回值:返回一个字符串,以0x开头
实例:
print("12的十六进制数为:", hex(12))
print("34的十六进制数为:", hex(34))
print("100的十六进制数为:", hex(100))
运行结果:
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
运行结果:
slice()函数-- 实现切片对象,主要用在切片操作函数里的参数传递。
语法:
class slice(stop) class slice(start, stop[, step])
参数:
- start--起始位置
- stop--结束位置
- step--间距
返回值:返回一个切片对象
实例:
myslice = slice(5) # 设置截取5个元素的切片
print(myslice)
arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(arr[myslice])
运行结果:
any()函数--用于判断给定的可迭代参数 iterable 是否全部为 False,则返回 False,如果有一个为 True,则返回 True
注意:元素除了是 0、空、FALSE 外都算 TRUE。
语法:any(iterable) # iterable:元组或者列表
返回值:
如果都为空、0、false,则返回false,如果不都为空、0、false,则返回true。
实例:
print(any(['a', 'b', 'c', 'd'])) # 列表list,元素都不为空或0
print(any(['a', 'b', '', 'd'])) # 列表list,存在一个为空的元素
print(any([0, '', False])) # 列表list,元素全为0,'',false
print(any(('a', 'b', 'c', 'd'))) # 元组tuple,元素都不为空或0
print(any([])) # 空列表
print(any(())) # 空元组
运行结果:
id()函数--返回对象的唯一标识符,标识符是一个整数
语法:id([object]) # object:对象
返回值:返回对象的内存地址
实例:
a = 'runoob'
print(id(a))
b = 1
print(id(b))
运行结果:
sorted()函数--随所有可迭代的对象进行排序操作
sort 与 sorted 区别:
sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。
语法:
sorted(iterable, key=None, reverse=False)
参数:
- iterable:可迭代对象
- key:主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取决于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
- reverse:排序规则,reverse = True 降序 , reverse = False 升序(默认)。
返回值:返回重新排序的列表
实例:
print(sorted([5, 2, 3, 1, 4])) # 默认为升序
# sorted() 函数可以接收任何的 iterable。
print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}))
# 利用key进行倒序排序
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list)
# 要进行反向排序,也通过传入第三个参数 reverse=True
example_list1 = [5, 0, 6, 1, 2, 7, 3, 4]
print(sorted(example_list1, reverse=True))
运行结果:
ascii()函数--返回一个表示对象的字符串
注意:对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符
语法:ascii(object) # 对象
返回值:返回字符串
实例
print(ascii('你好'))
print(ascii('a'))
print(ascii(10))
运行结果:
enumerate()函数--将一个可便利的数据对象(如列表、元组或者字符串)组合为一个索引序列,同时列出数据和下表
提示:一般用于for循环中
语法:enumerate(sequence, []start=0])
参数:
- sequence:一个序列、迭代器或者其他支持迭代对象。
- start:下标起始位置
返回值:
返回enumerate(枚举)类型
实例:
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
# 普通的for循环
seq = ['one', 'two', 'three']
for index, item in enumerate(seq):
print(index, item)
index +=
运行结果:
oct()函数--将一个整数转换成八进制字符串
提示:八进制以0o作为前缀表示。
语法:oct(x) # x--整数
返回值:返回八进制字符串
实例:
print(oct(10))
print(oct(100))
print(oct(7))
运行结果:
bin()函数--返回一个整数int类型的二进制
语法:bin(x) # x :int类型数据
返回值:字符串
实例:
print(bin(10))
print(bin(8))
print(bin(66))
运行结果:
eval()函数--用来执行一个字符串表达式,并返回表达式的值
语法:
eval(expression[, globals[, locals]])
参数:
- expression -- 表达式。
- globals -- 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
- locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
返回值:返回表达式计算的结果
实例:
print('3 * 5')
print(eval('3 * 5'))
a = eval('input("请输入一个数:")')
print(a)
运行结果:
int()函数--用于将一个字符串或数字转换为整型
语法:
class int(x, base=10)
参数:
- x -- 字符串或数字。
- base -- 进制数,默认十进制
实例:
print(int(0x78))
print(int(3.6))
print(int("67"))
print(int('10', 7))
运行结果:
open()函数--用于打开一个文件,并返回文件对象
提示:在对文件进行处理过程都需要使用到这个函数,如果该文件无法被打开,会抛出 OSError。
注意:使用 open() 函数一定要保证关闭文件对象,即调用 close() 函数。
语法格式:
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+ | 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。 |
实例:
创建测试文本文件test.txt,内容如下:
1234567
f = open('test.txt')
s = f.read()
print(s)
运行结果:
str()函数--将对象转换为适于人阅读的形式(字符串)
语法: class str(object='') # object :对象
返回值:返回一个对象的string格式
实例:
s = "hello world"
print(str(s))
b = 18
print(b, type(b))
c = str(18)
print(c, type(c))
运行结果:
bool()函数--用于将给定参数类型转换为布尔类型,如果没有参数,返回False
提示:bool为int的子类
语法:class bool([x]) # x:要进行转换的参数
返回值:返回True或者False
实例:
print(bool())
print(bool(1))
print(bool(0))
print(issubclass(bool, int)) # bool 是 int 子类
运行结果:
exec()函数--执行储存在字符串或文件中的 Python 语句
提示:相比于 eval,exec可以执行更复杂的 Python 代码。
语法:exec(object[, globals[, locals]])
参数:
- object:必选参数,表示需要被指定的 Python 代码。它必须是字符串或 code 对象。如果 object 是一个字符串,该字符串会先被解析为一组 Python 语句,然后再执行(除非发生语法错误)。如果 object 是一个 code 对象,那么它只是被简单的执行。
- globals:可选参数,表示全局命名空间(存放全局变量),如果被提供,则必须是一个字典对象。
- locals:可选参数,表示当前局部命名空间(存放局部变量),如果被提供,可以是任何映射对象。如果该参数被忽略,那么它将会取与 globals 相同的值。
返回值:无
实例:
exec('print("12345")')
exec("""for i in range(5):\
print ("iter time: %d" % i)\
""")
运行结果:
isinstantce()函数--来判断一个对象是否是一个已知的类型,类似 type()。
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
语法:isinstance(object, classinfo)
参数:
- object -- 实例对象。
- classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。
a = 2
print(isinstance(a, int))
print(isinstance(a, str))
print(isinstance(a, (str, int, list))) # 是元组中的一个返回 True
print("="*8)
# type() 与 isinstance()区别:
class A:
pass
class B(A):
pass
print(isinstance(A(), A))
print(type(A()) == A)
print(isinstance(B(), A))
print(type(B()) == A)
运行环境:
ord()函数--以一个字符串(Unicode 字符)作为参数,返回对应的 ASCII 数值
提示:ord() 函数是 chr() 函数(对于 8 位的 ASCII 字符串)的配对函数
语法:ord(c) # c:字符
返回值:返回值对应的十进制整数。
print(ord('a'))
print(ord('A'))
print(ord('你'))
运行结果:
sum()函数--对序列进行求和计算
语法:sum(iterable[, start])
参数:
- iterable -- 可迭代对象,如:列表、元组、集合。
- start -- 指定相加的参数,如果没有设置这个值,默认为0。
返回值:返回计算结果。
实例:
list1 = [2, 3, 4, 5, 6]
print(sum(list1))
print(sum((3, 2, 12), 5))
运行结果:
bytearray()函数--返回一个新字节数组。
注意:这个数组的元素是可变的,并且每一个元素的取值范围:0<=x<=256.
语法: class bytearray([source[, encoding[, errors]]])
参数:
- 如果 source 为整数,则返回一个长度为 source 的初始化数组;
- 如果 source 为字符串,则按照指定的 encoding 将字符串转换为字节序列;
- 如果 source 为可迭代类型,则元素必须为[0 ,255] 中的整数;
- 如果 source 为与 buffer 接口一致的对象,则此对象也可以被用于初始化 bytearray。
- 如果没有输入任何参数,默认就是初始化数组为0个元素。
返回值:返回新字节数组
实例:
print(bytearray())
print(bytearray([1, 2, 3]))
print(bytearray('runoob', 'utf-8'))
运行结果
filter()函数--用于过滤序列,过滤掉不符合条件的元素,返回一个迭代器对象。
提示:如果要转换为列表可以使用list()来转换。该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判断,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
语法:filter(function, iterable)
参数:
- function -- 判断函数。
- iterable -- 可迭代对象
返回值:返回一个迭代器对象
实例:
import math
# 过滤出列表中的所有技术
def is_odd(n):
return n % 2 == 1
tmlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8])
newlist = list(tmlist)
print(newlist)
# 过滤出1~100中平方根是整数的数
def is_sqr(x):
return math.sqrt(x) % 1 == 0
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
print(newlist)
运行结果
issubclass()函数--用于判断参数class是否是类型参数classinfo的子类型
语法:issubclass(class, classinfo)
参数:
- class -- 类。
- classinfo -- 类。
返回值:如果class是classinfo的子类返回True,否则返回False
实例:
class A:
pass
class B(A):
pass
print(issubclass(B, A))
运行结果:
pow()函数--返回
(x的y次方)的值
语法:
- math模块的pow()方法: math.pow( x, y ) # 注意:要先导入math模块
- 内置的pow()方法 pow(x, y[, z]) #如果z在存在,则再对结果进行取模,其结果等效于pow(x,y) %z
参数:
- x -- 数值表达式。
- y -- 数值表达式。
- z -- 数值表达式。
返回值:返回的值
实例:
import math # 导入math模块
print("math.pow(100,2):", math.pow(100, 2))
# 使用内置,查看输出结果区别
print("pow(100, 2) : ", pow(100, 2))
print("math.pow(100, -2) : ", math.pow(100, -2))
print("math.pow(2, 4) : ", math.pow(2, 4))
print("math.pow(3, 0) : ", math.pow(3, 0))
运行结果:
super()函数--调用父类(超类)的方法。
提示:super() 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。
语法:super(type[, object-or-type])
参数:
- type -- 类。
- object-or-type -- 类,一般是 self
实例:
class A:
def add(self, x):
y = x + 1
print(y)
class B(A):
def add(self, x):
super().add(x)
b = B()
b.add(2)
运行结果:
bytes()函数--返回一个新的bytes对象。
提示:该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。
语法:class bytes([source[, encoding[, errors]]])
参数:
- 如果 source 为整数,则返回一个长度为 source 的初始化数组;
- 如果 source 为字符串,则按照指定的 encoding 将字符串转换为字节序列;
- 如果 source 为可迭代类型,则元素必须为[0 ,255] 中的整数;
- 如果 source 为与 buffer 接口一致的对象,则此对象也可以被用于初始化 bytearray。
- 如果没有输入任何参数,默认就是初始化数组为0个元素。
返回值:返回一个新的bytes对象
实例:
a = bytes([1, 2, 3, 4])
print(a, type(a))
a = bytes('hello', 'ascii')
print(a, type(a))
运行结果:
float()函数--用于将整数和字符串转换成浮点型
语法:class float([x]) # x:整数和字符串
返回值:返回浮点数
实例:
print(float(1), type(float(1)))
print(float("10"), type(float("10")))
运行结果:
iter()函数--用来生成迭代器。
语法:iter(object[, sentinel])
参数:
- object -- 支持迭代的集合对象。
- sentinel -- 如果传递了第二个参数,则参数 object 必须是一个可调用的对象(如,函数),此时,iter 创建了一个迭代器对象,每次调用这个迭代器对象的__next__()方法时,都会调用 object。
返回值:迭代器
实例:
lst = [1, 2, 3]
for i in iter(lst):
print(i)
运行结果:
print()函数--用于打印输出,最常见的一个函数。
语法:print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
参数:
- objects -- 复数,表示可以一次输出多个对象。输出多个对象时,需要用 , 分隔。
- sep -- 用来间隔多个对象,默认值是一个空格。
- end -- 用来设定以什么结尾。默认值是换行符 \n,我们可以换成其他字符串。
- file -- 要写入的文件对象。
- flush -- 输出是否被缓存通常决定于 file,但如果 flush 关键字参数为 True,流会被强制刷新。
返回值:无
实例:
print(1)
print("hello world")
a = 1
b = 'runoob'
print(a, b)
print("aaa""bbb")
print("aaa", "bbb")
print("www", "runoob", "com", sep=".") # 设置间隔符
运行结果:
tuple()函数--将可迭代系列(如列表)转换为元组
语法:tuple( iterable ) # 要转换为元组的可迭代序列
返回值:返回元组
实例:
list1 = ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1 = tuple(list1)
print(tuple1)
a = {'www': 123, 'aaa': 234}
print(tuple(a))
a = set('abcd')
print(a)
print(tuple(a))
运行结果:
callable()函数--检查一个函数是否被调用。
提示:如果返回 True,object 仍然可能调用失败;但如果返回 False,调用对象 object 绝对不会成功。对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。
语法:callable(object) #对象
返回值:可调用返回 True,否则返回 False。
实例:
print(callable(0))
print(callable("runoob"))
def add(a, b):
return a + b
print(callable(add))
运行结果:
format()格式化函数
语法:基本语法是通过 {} 和 : 来代替以前的 %
format函数可以接受不限个数,位置可以不按顺序
实例:
print("{} {}".format("hello", "world")) # 不设置指定位置,按默认顺序
print("{0} {1}".format("hello", "world")) # 设置指定位置
print("{1} {0} {1}".format("hello", "world")) # 设置指定位置
# 设置参数
print("网站名:{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名:{name}, 地址 {url}".format(**site))
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名:{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的
运行结果:
数字格式化
^, <, > 分别是居中、左对齐、右对齐,后面带宽度, : 号后面带填充的字符,只能是一个字符,不指定则默认是用空格填充。
+ 表示在正数前显示 +,负数前显示 -; (空格)表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
len()方法--返回对象(字符,列表,元组等) 长度或项目个数
语法:len(s) # s :对象
返回值:返回对象的长度
实例:
str = "runoob"
print(len(str))
l = [1, 2, 3, 4, 5]
print(len(l))
运行结果:
property()函数--返回属性值
语法:class property([fget[, fset[, fdel[, doc]]]])
参数:
- fget -- 获取属性值的函数
- fset -- 设置属性值的函数
- fdel -- 删除属性值函数
- doc -- 属性描述信息
返回值:返回新式类属性
实例:
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()
print(c.x)
c.x = 4
print(c.x)
运行结果:
type()函数--返回参数的对象的类型
提示:如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
语法:
type(object)
type(name, bases, dict)
参数:
- name -- 类的名称。
- bases -- 基类的元组。
- dict -- 字典,类内定义的命名空间变量。
返回值:一个参数返回对象类型,三个参数,返回新的类型对象。
实例:
print(type(1))
print(type('runoob'))
print(type([2]))
print(type({0: 'zero'}))
运行结果:
chr()函数--用一个整数作为参数,返回一个对应的字符
语法:chr(i) # i:可以是 10 进制也可以是 16 进制的形式的数字,数字范围为 0 到 1,114,111
返回值:返回值是当前整数对应的ASCII字符
实例:
print(chr(0x30))
print(chr(97))
print(chr(787))
运行结果:
frozenset()函数--返回一个冻结的集合,冻结后集合不能在添加或删除任何元素。
语法:class frozenset([iterable]) # iterable -- 可迭代的对象,比如列表、字典、元组等等。
返回值:返回新的 frozenset 对象,如果不提供任何参数,默认会生成空集合。
实例:
a = frozenset(range(10)) # 生成一个新的不可变集合
print(a)
b = frozenset('runoob')
print(b)
运行结果:
List list()方法--用于将元组或字符串转换为列表
语法:list( seq ) # seq:要转换为列表的元组或字符串。
返回值:返回列表
实例:
aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print ("列表元素 : ", list1)
str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)
运行结果
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)
实例:
print(range(5))
for i in range(5):
print(i)
print(list(range(5)))
运行结果:
var()函数--返回对象object的属性和属性值的字典对象
语法:vars([object]) # 对象
返回值:返回对象object的属性和属性值的字典对象,如果没有参数,就打印当前调用位置的属性和属性值 类似 locals()。
实例:
print(vars())
class Runoob:
a = 1
print(vars(Runoob))
运行结果:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000014CC2A53348>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/pythonliu/lu.py', '__cached__': None}
{'__module__': '__main__', 'a': 1, '__dict__': <attribute '__dict__' of 'Runoob' objects>, '__weakref__': <attribute '__weakref__' of 'Runoob' objects>, '__doc__': None}
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() # 不需要实例化
运行结果:
getattr()函数--用于返回一个对象属性值
语法:getattr(object, name[, default])
参数:
- object -- 对象。
- name -- 字符串,对象属性。
- default -- 默认返回值,如果不提供该参数,在没有对应属性时,将触发 AttributeError。
返回值:返回对象属性值
实例:
class A(object):
bar = 1
a = A()
print(getattr(a, 'bar')) # 获取属性bar值
print(getattr(a, 'bar2', 3)) # 属性 bar2 不存在,但设置了默认值
print(getattr(a, 'bar2')) # 属性bar2不存在,触发异常
运行结果:
locals() 函数--以字典类型返回当前位置的全部局部变量
语法:locals()
返回值:返回字典类型的局部变量
实例:
def runoob(arg): # 两个局部变量:arg、z
z = 1
print(locals())
runoob(4)
运行结果:
repr() 函数-- 将对象转化为供解释器读取的形式
语法:repr(object) # object : 对象
返回值:返回一个对象string格式
实例:
s = 'RUNOOB'
print(repr(s))
dict1 = {'runoob': 'runoob.com', 'google': 'google.com'}
print(repr(dict1))
运行结果:
zip()函数
描述:将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象
我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。
语法:zip([iterable, ...]) # iterable, ...:一个或者多个迭代器
返回值:返回一个对象
实例:
a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
zipped = zip(a, b) # 返回一个对象
print(zipped)
print(list(zipped)) # list() 转换为列表
print(list(zip(a, ))) # 元素个数与最短的列表一致
a1, a2 = zip(*zip(a,b)) # 与 zip 相反,zip(*) 可理解为解压,返回二维矩阵式
print(list(a1))
print(list(a2))
运行结果:
compile()函数--将一个字符串编译为字节代码。
语法:compile(source, filename, mode[, flags[, dont_inherit]])
参数:
- source -- 字符串或者AST(Abstract Syntax Trees)对象。。
- filename -- 代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
- mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
- flags -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。。
- flags和dont_inherit是用来控制编译源码时的标志
返回值:返回表达式执行结果。
实例:
str1 = "for i in range(0,10): print(i)"
c = compile(str1, '', 'exec') # 编译为字节代码对象
print(c)
print(exec(c))
运行结果:
globals()函数--会以字典类型返回当前位置的全部全局变量
语法:globals()
返回值:返回全局变量的字典。
实例:
a = 'runoob'
print(globals()) # globals 函数返回一个全局变量的字典,包括所有导入的变量。
运行结果:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000021E62333348>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/pythonliu/lu.py', '__cached__': None, 'a': 'runoob'}
map()函数--会根据提供的函数对指定序列做映射。
语法:map(function, iterable, ...)
参数:
- function -- 函数
- iterable -- 一个或多个序列
返回值:返回一个迭代器
def square(x) : # 计算平方数
return x ** 2
print(map(square, [1, 2, 3, 4, 5])) # 计算列表各个元素的平方
print(list(map(square, [1, 2, 3, 4, 5]))) # 使用 list() 转换为列表
print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))) # 使用 lambda 匿名函数
运行结果:
reversed()函数--返回一个反转的迭代器
语法:reversed(seq) # 要转换的序列,可以是tuple,string,list或range
返回值:返回一个反转的迭代器。
实例:
# 字符串
seqString = 'Runoob'
print(list(reversed(seqString)))
# 元组
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple)))
# range
seqRange = range(5, 9)
print(list(reversed(seqRange)))
# 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))
运行结果:
__import__()函数-- 用于动态加载类函数。
提示:如果一个模块经常变化就可以使用__import__()来动态载入
语法:__import__(name[, globals[, locals[, fromlist[, level]]]]) # name -- 模块名
返回值:返回元组列表
# a.py文件代码
import os
print('在 a.py 文件中 %s' % id(os))
# b.py文件代码
import sys
__import__('a') # 导入 a.py 模块
运行结果:
complex()函数--用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数
如果第一个参数为字符串,则不需要指定第二个参数
语法:class complex([real[, imag]])
参数:
- real -- int, long, float或字符串;
- imag -- int, long, float;
返回值:返回一个复数
实例:
print(complex(1, 2))
print(complex(1))
print(complex("1"))
# 注意:这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错
print(complex("1+2j"))
运行结果:
hasattr()函数-- 用于判断对象是否包含对应的属性。
语法:hasattr(object, name)
参数:
- object -- 对象。
- name -- 字符串,属性名。
返回值:如果对象有该属性返回 True,否则返回 False。
实例:
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no')) # 没有该属性
运行结果:
max()函数--返回给定参数的最大值,参数可以是序列
语法:max( x, y, z, .... )
参数:
- x -- 数值表达式。
- y -- 数值表达式。
- z -- 数值表达式。
返回值:返回给定参数的最大值
实例:
print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))
print ("max(0, 100, -400) : ", max(0, 100, -400))
运行结果:
round()函数--返回浮点数 x 的四舍五入值,准确的说保留值将保留到离上一位更近的一端
提示:精度要求高的不建议使用该函数。
语法:round( x [, n] )
参数:
- x -- 数字表达式。
- n -- 表示从小数点位数,其中 x 需要四舍五入,默认值为 0。
返回值:返回浮点数x的四舍五入值
实例:
print("round(70.23456) : ", round(70.23456))
print("round(56.659,1) : ", round(56.659,1))
print("round(80.264, 2) : ", round(80.264, 2))
print("round(100.000056, 3) : ", round(100.000056, 3))
print("round(-100.000056, 3) : ", round(-100.000056, 3))
运行结果:
reload()函数--用于重新载入之前的模块
语法:
import importlib
importlib.reload(module)
或者:
from importlib import reload
reload(module)
参数:module -- 模块对象。
返回值:返回模块对象
实例:
import sys, importlib
print(importlib.reload(sys))
运行结果:
delattr()函数--用于删除属性
delattr(x, 'foobar') 相等于 del x.foobar
语法:delattr(object, name)
参数:
- object -- 对象。
- name -- 必须是对象的属性。
返回值:无
实例:
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
print('x = ', point1.x)
print('y = ', point1.y)
print('z = ', point1.z)
delattr(Coordinate, 'z')
print('--删除 z 属性后--')
print('x = ', point1.x)
print('y = ', point1.y)
# 触发错误
print('z = ', point1.z)
运行结果:
hash()函数--用于获取取一个(字符串或者数值等)的哈希值
语法:hash(object) # object -- 对象;
返回值:返回对象的哈希值
实例:
print(hash('test'))
print(hash(str([1, 2, 3])))
运行结果:
memoryview()函数--返回给定参数的内存查看对象
所谓内存查看对象,是指对支持缓冲区协议的数据进行包装,在不需要复制对象基础上允许Python代码访问。
语法:memoryview(obj) # obj:对象
返回值:元组列表
实例:
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])
print(v[-1])
print(v[1:4])
print(v[1:4].tobytes())
运行结果:
set()函数--创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。
语法:class set([iterable]) # iterable -- 可迭代对象对象;
返回值:返回新的集合对象。
实例:
x = set('runoob')
y = set('google')
print(x, y) # 去重
print(x & y) # 交集
print(x | y) # 并集
print(x - y) # 差集
运行结果:
参考网址:Python 基础教程 | 菜鸟教程