目录
- 获取数字的绝对值(abs)
- 创建一个复数(complex)
- 四舍五入(round)
- 获取两数相除的商和余数(divmod)
- 控制台输入(input)
- 打开文件(open)
- 把元组、字符串、等转换为列表(list)
- 把多个数组、对象转化成一个元组(zip)
- 把列表等转换为元组(tuple)
- 将两个数组转换为字典(dict)
- 查看函数或模块用途的详细说明(help)
- 查看一个源文件(模块)的属性和方法(dir)
- 获得最小值(min)
- 获得最大值( max)
- 多次调用一个函数(map)
- 无序不重复的集合(set)
- 生成一定范围的数字(range)
- 设置类、对象的属性(setattr)
- 获得类、对象的属性(getattr)
- 判断类是否有某个属性(hasattr)
- 删除某个类的属性(delattr)
- 判断所有元素是否都为有效值(all)
- 判断所有元素是否都为无效值(any)
- 将一个十进制的数转化为十六进制(hex)
- 将一个数转化为八进制(oct)
- 将一个数转化为二进制(bin)
- 转换为迭代器(iter)
- 返回迭代器的下个元素(next)
- 分割元素(slice)
- 返回对象的内存地址(id)
- 对可迭代器中的元素进行排序(sorted)
- 返回对象的编码字符(ascii)
- 获得下标和对应的值(enumerate)
- 转化为int类型(int)
- 转化为str类型(str)
- 转化为float类型(float)
- 转化为bool类型(bool)
- 将一个字符转换为数字(ord)
- 将一个数字转为字符(chr)
- 静态方法(staticmethod)
- 类方法(classmethod)
- 执行字符串格式的代码(eval)
- 执行字符串格式的代码(exec)
- 编译执行字符串格式的代码(compile)
- 获得对象的类型(type)
- 判断两者的类型是否相同(isinstance)
- 判断两者是否为父子关系(issubclass)
- 求全部元素的总和(sum)
- 留下某些符合条件的元素(filer)
- X的Y次方(pow)
- 转化为字节格式(bytes)
- 转化为字节数组格式(bytesarray)
- 调用父类的函数(super)
- 检查一个对象是否可调用(callable)
- 输出内容(print)
- 格式化(format)
- 获取全部元素的个数(len)
- 获取、设置、删除类的属性(property)
- 冻结的集合(frozentset)
- 获取对象的属性和值(vars)
- 获取当前位置的局部变量(locals)
- 获取当前位置的全局变量(globals)
- 获取对象的解释器形式
- 颠倒前后元素(reversed)
- 动态导入模块(__import__)
- 获取一个对象的hash值(hash)
获取数字的绝对值(abs)
"""
参数可以是整数、浮点数、复数(z=a+bj) 如果你不知道复数是啥,当我没说= 。=
"""
# 输出整数的绝对值 结果:1
print(abs(-1))
# 输出浮点数的绝对值 结果:1.5
print(abs(-1.5))
# 输出复数的绝对值 结果:2.23606797749979
print(abs(1 + 2j))
创建一个复数(complex)
# 创建输出一个复数
# 输出:(1+2j)
print(complex(1, 2))
四舍五入(round)
# 四舍五入 该方法不太精确,不能适用于精确计算
# 保留小数点后两位 输出:2.67 别奇怪结果,都说了不太准确
print(round(2.675, 2))
获取两数相除的商和余数(divmod)
"""
参数可以是整数、浮点数
返回值的格式(a//b,a%b) a//b是整除
"""
# 输出5.1除2.1的商和余数 输出结果:(2.0, 0.8999999999999995)
print(divmod(5.1, 2.1))
控制台输入(input)
"""
参数是字符串类型
可以接受任意内容,把接受的内容转换成字符串类型
"""
# 接收控制台输入的内容
info = input("输入内容:")
# 打印内容
print(info)
打开文件(open)
"""
参数:
mode: 可选,文件打开的模式
默认为r,常用的就r、w、a、b
模式 描述
t 以文本格式打开
x 写模式,新建一个文件,如果该文件已存在则会报错。
b 以二进制模式读取
+ 打开一个文件进行,可读可写。
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w 打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。
a 打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。
buffering: 设置缓冲
设置为0时,表示不使用缓冲区,直接读写,仅在二进制模式下有效。
设置为1时,表示在文本模式下使用行缓冲区方式。
设置为大于1时,设置缓冲区的大小
为什么要使用缓冲区?
比如我们从磁盘读取信息,我们先把读出的数据放在缓冲区,计算机再直接从缓冲区中取数据,
等缓冲区的数据取完后再去磁盘中读取,这样就可以减少磁盘的读写次数,再加上计算机对缓冲区的操作大大快于对磁盘的操作,
故使用缓冲区可大大提高计算机的运行速度。
encoding: 编码
一般使用utf8
参数encoding是指明对文件编码,仅适用于文本文件。
如果不指定编码方式,默认是使用locale.getpreferredencoding()函数返回的编码方式。
errors: 报错级别
newline: 确定换行符
文本模式之下,设定一行的结束字符。
当在读取模式下,如果新行符为None,那么就作为通用换行符模式工作,意思就是说当遇到\n,\r或\r\n都可以作为换行标识,并且统一转换为\n作为文本输入的换行符。
当设置为’’时,也是通用换行符模式工作,但不转换为\n,输入什么样的,就保持原样全输入。
当设置为其它相应字符时,就会判断到相应的字符作为换行符,并保持原样输入到文本。
三种操作系统下的换行符:
在Windows中:
'\r' 回车,回到当前行的行首,而不会换到下一行,如果接着输出的话,本行以前的内容会被逐一覆盖;
'\n' 换行,换到当前位置的下一行,而不会回到行首;
Windows系统里面,每行结尾是“<回车><换行>”,即“\r\n”;
Unix系统里,每行结尾只有“<换行>”,即"\n";
Mac系统里,每行结尾是“<回车>”,即"\r";
一个直接后果是,Unix/Mac系统下的文件在Windows里打开的话,所有文字会变成一行;而Windows里的文件在Unix/Mac下打开的话,在每行的结尾可能会多出一个^M符号
因为三种操作系统的文本换行符不一致,跨平台时对文本文件非常不友好,在判定是否换行时容易出问题。
closefd: 传入的file参数类型
总结:文本文件处理时应该当心,一是缓冲区,二是编码、三是换行符(三种操作系统换行符不一致)
"""
# 打开nihao.txt,可读可写,使用缓冲区,编码为'utf-8',newline设置为\r\n(windows操作系统的换行规则)
file = open('测试.txt', mode='r+', buffering=1, encoding='utf-8', newline='\r\n')
把元组、字符串、等转换为列表(list)
"""
1、把字符串转换为列表
结果:['1', '2', '3']
相当于把字符串的每个字符都放到列表
"""
a = list('123')
print(a)
"""
2、把元组转换为列表
结果:[1, 2]
相当于把最外层的小括号换位中括号
"""
b = list((1, 2))
print(b)
把多个数组、对象转化成一个元组(zip)
"""
1、将多个对象中的对应元素打包成一个元组,节省内存。
例如:原来有三个对象,现在把这三个对象打包成一个元组对象,那么就减少了两个对象的内存开销,也不会丢失数据。
"""
# 定义两个数组对象
a = [1, 2, 3]
b = [4, 5, 6]
# 进行对象打包
result = zip(a, b)
# 把打包的对象转换成列表输出,转换成列表输出是因为容易观察。
# 输出结果:[(1, 4), (2, 5), (3, 6)]
print(list(result))
"""
2、将打包后的元组对象转换为多个对象(zip的逆过程)
"""
# 定义两个数组对象
a = [1, 2, 3]
b = [4, 5, 6]
# 打包对象
result = zip(a, b)
# 解包对象
c, d = zip(*result)
# 输出解包后的对象
# 输出结果:(1, 2, 3) (4, 5, 6)
print(c, d)
"""
3、如果多个对象元素的个数不一样,那么打包的时候会发生什么?
打包出来的元组长度和这些对象中最短的长度一致,木桶中水的高度取决于最短木板的高度。
"""
# 定义两个数组对象 a的长度为4,b的长度为3
a = [1, 2, 3, 4]
b = [4, 5, 6]
# 打包两个对象
c = zip(a, b)
# 输出打包后的内容
# 输出内容:[(1, 4), (2, 5), (3, 6)] 长度为3 和对象中最短的长度一致
print(list(c))
把列表等转换为元组(tuple)
# 字符串转换为元组 输出:('1', '2', '3')
a = '123'
print(tuple(a))
# 列表转换为元组 输出:('1', '2', '3')
b = ['4', '5', '6']
print(tuple(b))
# 集合转换为元组 输出:(1, 2, 3)
c = {1, 2, 3}
print(tuple(c))
# 字典转换为元组 输出:(1, 3) 只获取字典的key
d = {1: 2, 3: 4}
print(tuple(d))
将两个数组转换为字典(dict)
"""
将两个数组转换为字典
1、利用zip对两个数组进行打包
2、利用dic对打包后的元组对象转换为字典
"""
# 定义两个数组对象
a = [1, 2, 3]
b = [4, 5, 6]
# 打包两个数组对象
c = zip(a, b)
# 转换为字典
result = dict(c)
# 输出字典
# 输出结果:{1: 4, 2: 5, 3: 6}
print(result)
查看函数或模块用途的详细说明(help)
import sys
# 查看sys模块的详细内容,也就是说明书
print(help('sys'))
查看一个源文件(模块)的属性和方法(dir)
# 输出当前源文件中的变量、方法。
print(dir())
# 输出字符串源文件中的变量和方法
print(dir(''))
# 输出列表源文件中的变量和方法
print(dir([]))
# 以此类推
获得最小值(min)
"""
比较规则:每个字符都有一个编码的值,按照编码进行排序,获得最小值
"""
"""
1、min的参数是列表
输出:1
"""
a = [1, 2, 3]
print('列表')
print(min(a))
"""
2、min的参数是元组
输出:4
"""
b = (4, 5, 6)
print('元组')
print(min(b))
"""
3、min的参数是集合
输出:4
"""
b = {4, 5, 6}
print('集合')
print(min(b))
"""
4、min的参数是字典
"""
b = {'a': 4, 'b': 5, 'b': 3}
# 获取字典最小key 输出:a
print('字典的key')
print(min(b))
# 获取字典最小value 输出:3
print('字典的value的key')
# 获取字典最小value的key 这里的参数key是比较的规则,元素根据参数key的规则进行比较,找到最小值
minKey = min(b, key=lambda x: [b[x]])
# 根据key得到value
print(b[minKey])
"""
5、min的参数是字符串
输出:a
实质上:把字符串每个字符转换为列表,再进行min的类似操作
"""
c = "abc"
print(min(c))
"""
6、min的参数是多个变量
输出:1
"""
print(min(1, 2, 3))
获得最大值( max)
和’获得最小值’没啥区别,只是一个最小,一个最大。请往上滑查看详细内容。
多次调用一个函数(map)
"""
map:多次调用一个函数,输入n个列表,输出一个列表。
第一个参数是函数,也可以是lambda表达式
第二个参数是n个列表,取决于函数要使用参数的数量
"""
"""
输出列表中值的绝对值,相当于列表中的每个数都调用了abs函数。
使用list是因为可以展示结果。
输出:[1, 2, 1]
"""
print(list(map(abs, [1, 2, -1])))
# 定义函数计算两个数的和
def add(x, y):
return x + y
"""
输出两个数组对应值相加的结果,为什么需要两个列表?
因为add函数需要两个参数,第一个列表相当于x的值,第二个列表相当于y的值
输出:[2, 4, 6]
"""
print(list(map(add, [1, 2, 3], [1, 2, 3])))
"""
函数也可以换成lambda表达式
例如:lambda x, y: x + y x,y代表两个参数 x+y是返回的值 中间用冒号分开
输出两个数组对应值相加的结果,和上面功能一致,只不过换成了lambda表达式
输出:[2, 4, 6]
"""
print(list(map(lambda x, y: x + y, [1, 2, 3], [1, 2, 3])))
无序不重复的集合(set)
"""
set:无序不重复
无序是指:元素进出的顺序不一致 可能a先进来,a最后一个出去。
不重复是因为set使用hashcode来存储,一个hashcode只能对应一个值。
"""
# 输出自定义一个集合 输出:{'i', 'Q', 'u', 'X', 'n', 'a', 'F'}
a = set('QianFuXin')
print(a)
# 定义一个集合
b = set('DiLiReBa')
# 输出a和b的交集
print(a & b)
# 输出a和b的并集
print(a | b)
# 输出a和b差集 在集合a中但不在集合b中的元素。
print(a - b)
# 输出两个集合的补集 集合a和b的非共同元素。
print(a ^ b)
生成一定范围的数字(range)
"""
range没啥好说的,就是生成一定范围的数字
参数如下:
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)
"""
# 输出1-20(不包括20)之间的奇数
# 结果:[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
print(list(range(1, 20, 2)))
设置类、对象的属性(setattr)
"""
# A类
class A:
# 类变量
name = '小明'
def __init__(self, name):
# 实例变量
self.name = name
如果第一个参数是类,那就设置类变量的值
如果第一个参数是对象,那就设置对象变量的值
如果变量不存在,那就创建这个变量
"""
# 实例化对象
a = A('小红')
# 设置对象变量'name'的值为'小刚'
setattr(a, 'name', '小刚')
# 输出验证 输出:小刚
print(getattr(a, 'name'))
# 如果变量不存在,创建变量,创建'sex'变量
setattr(a, 'sex', 'man')
# 输出验证 输出:man
print(getattr(a, 'sex'))
获得类、对象的属性(getattr)
"""
# A类
class A:
# 类变量
name = '小明'
def __init__(self, name):
# 实例变量
self.name = name
如果第一个参数是类,那就获取类变量的值
如果第一个参数是对象,那就获取对象变量的值
如果变量不存在,会异常
"""
# 实例化对象
a = A('小红')
# 获取对象变量'name'的值 输出:小红
print(getattr(a, 'name'))
# 获取类变量'name'的值 输出:小明
print(getattr(A, 'name'))
判断类是否有某个属性(hasattr)
# 类A
class A:
# 部门属性
deparment = '1'
def __init__(self, name):
# 姓名属性
self.name = ''
# 判断A类对象是否有name、age属性
a = A('小明')
# 输出:True
print(hasattr(a, 'name'))
# 输出:False
print(hasattr(a,'sex'))
删除某个类的属性(delattr)
# 类A
class A:
# 部门属性
deparment = '1'
def __init__(self, name):
# 姓名属性
self.name = ''
# 删除deparment属性
delattr(A, 'deparment')
判断所有元素是否都为有效值(all)
有效值的定义:除了 0、’’、None、False 外都是有效值
"""
all:全部元素都为有效值,才返回True,列表(元组等其他)长度为0,也返回True
有效值:除了 0、''、None、False 外都是有效值
适用:列表、元组、集合、字典(只和key的值有关)、字符串
"""
# 虽然字典的value是无效值,但是字典的key是有效值,所以返回True
d = {'1': '', '2': None, '3': False}
# 输出:True
print(all(d))
判断所有元素是否都为无效值(any)
无效值的定义: 0、’’、None、False
"""
any:只要有一个元素为有效值,就返回True,列表(元组等其他)长度为0,返回False
有效值:除了 0、''、None、False 外都是有效值
适用:列表、元组、集合、字典(只和key的值有关)、字符串
"""
# 虽然字典只有一个key是有效值,any也返回True
d = {'': 1, '': 2, '3': 3}
# 输出:True
print(any(d))
将一个十进制的数转化为十六进制(hex)
# 输出42的十六进制 输出:0x2a
print(hex(42))
将一个数转化为八进制(oct)
# 输出42的八进制 输出:0o52
print(oct(42))
将一个数转化为二进制(bin)
# 输出12的二进制 输出:0b1100
print(bin(12))
转换为迭代器(iter)
"""
iter的作用:1、将列表、元组等对象转换为可迭代对象
2、重复调用一个函数,持续到函数的返回值等于你设定的值
适用:列表、元组、集合、字符串
"""
# 将列表转换为可迭代对象 个人感觉写不写iter都一样
a = [1, 2, 3, 4]
for i in iter(a):
print(i)
import random
# 定义函数
def randomNumber():
# 随机返回1-10的数字
return random.randint(1, 10)
# 随机得到1-10的数字,如果数字是3,结束循环
for i in iter(randomNumber, 3):
# 输出数字
print(i)
返回迭代器的下个元素(next)
# 定义迭代器 适用:列表、元组、集合、字符串
a = iter([1, 2, 3, 4])
while True:
# 获得迭代器的下个元素,如果数组迭代结束,就返回'over'
element = next(a, 'over')
# 输出元素
print(element)
# 终止循环
if element == ('over'):
break
分割元素(slice)
"""
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
获得a的前6项该怎么处理?
新手:a[0],a[1],a[2],a[3],a[4],a[5]
入门:a[:6]
ok,获得a的前6项的奇数项怎么处理?
入门的方法就无从下手了,需要使用slice
slice的三个参数:起始位置、结束位置、步长
适用:列表、元组、字符串
"""
# 自定义列表
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 构建slice,起始位置是0,结束位置是6,步长是2
s = slice(0, 6, 2)
# 输出a的前六项的奇数项 输出:1、3、5
print(a[s])
返回对象的内存地址(id)
a = 3
# 输出a的内存地址 输出:4311182192
print(id(a))
a = 4
# 输出a的内存地址 输出:4438428560
print(id(a))
对可迭代器中的元素进行排序(sorted)
"""
默认升序,如果想降序,reverse=True
支持:列表、元组、集合、字典、字符串
"""
# 定义列表
a = [-9, 2, 8, 1]
# 输出降序
print(sorted(a, reverse=True))
# 输出按照绝对值进行降序 key是排序的规则,只是排序,不改变元素的值。
print(sorted(a, key=abs, reverse=True))
# 定义字典
b = {1: 100, 2: 20, 3: 50}
# 输出按照字典的key降序
print(sorted(b, reverse=True))
# 输出按照字典的value降序
print(sorted(b, key=lambda x: b[x]))
返回对象的编码字符(ascii)
# 输出对象的编码字符,默认使用ASCII编码,如果超出该编码的范围,就使用\u或者\x
# 输出结果:'22\u5c81\u4e86'
print(ascii('22岁了'))
获得下标和对应的值(enumerate)
"""
enumerate:输出列表的下标和对应的值 下标的值默认从0开始,也可设置其他值
适用:元组、列表、字符串
"""
a = [1, 2, 3]
# 输出列表的下标和对应的值,默认从1开始使用list是因为方便输出
# 输出:[(1, 1), (2, 2), (3, 3)]
print(list(enumerate(a, start=1)))
转化为int类型(int)
# str转换为int类型 输出:3
print(int('3'))
# float转换为int类型 输出:3
print(int(3.12))
# bool转换为int类型 输出:0 如果是True,输出1
print(int(False))
转化为str类型(str)
# int转换为str类型 输出:3
print(str(3))
# float转换为str 输出:3.12
print(str(3.12))
# bool转化为str 输出:True
print(str(True))
转化为float类型(float)
# int转换为float类型 输出:3.0
print(float(3))
# str转换为float类型 输出3.1
print(float('3.1'))
# bool转换为float类型 输出:1.0 如果是False,输出0.0
print(float(True))
转化为bool类型(bool)
# int转换为bool类型 只有0输出False,其他值都输出True
# 输出:True
print(bool(1))
# float转换为bool类型 只有0.0输出False,其他值都输出True
# 输出:True
print(bool(0.1))
# str转换为bool类型 只有None和''输出False,其他值都输出True
# 输出:False
print(bool(None))
将一个字符转换为数字(ord)
# 输出字符'a'的数字形式 输出结果:97
print(ord('a'))
将一个数字转为字符(chr)
# 输出数字123的字符内容 输出结果:{
print(chr(123))
静态方法(staticmethod)
class A:
def __init__(self ):
pass
# 该函数的作用:输出一个随机数,和类、对象都没有鸟关系,所以可以把该函数设为static
@staticmethod
def randomNumber():
print(random.randint(1, 100))
"""
staticmethod
当某个方法不需要用到对象和类的任何资源时,可以把这个方法改为一个静态方法, 在方法上方加一个@staticmethod。
类和实例都可以调用该函数
"""
# 实例调用该方法
A().randomNumber()
# 类调用该方法
A.randomNumber()
类方法(classmethod)
class A:
# 类A已经实例化对象的个数,实例化一个对象,number就+1
number = 0
def __init__(self):
# 实例化对象数量+1
A.number += 1
# 查看当前已经实例化对象的个数,用类就可以调用此函数
@classmethod
def printNumber(cls):
print('已经实例化' + str(cls.number) + '个对象')
if __name__ == '__main__':
# 不用创建实例就可以调用此函数
A.printNumber()
执行字符串格式的代码(eval)
"""
eval函数 执行字符串格式的代码,不建议使用,会带来系统安全风险(百度去)
参数:
单个表达式
全局变量
局部变量
"""
a = 1
b = 2
# 输出:3
result = eval('a+b')
print(result)
# 使用全局变量 见到a替换成3,见到b替换成4 输出:7
result = eval('a+b', {'a': 3, 'b': 4})
print(result)
# 同时使用全局变量和局部变量 两者同时存在且发生冲突,局部变量说的算... 输出:30
result = eval('a+b', {'a': 3, 'b': 4}, {'a': 10, 'b': 20})
print(result)
"""
表达式相当于孩子
全局变量相当于爸爸
局部变量相当于妈妈
爸爸在,听爸爸的话,妈妈在,听妈妈的话,爸爸妈妈同时在,优先听妈妈的话.....
"""
执行字符串格式的代码(exec)
"""
exec函数 执行字符串格式的代码,不建议使用,会带来系统安全风险(百度去)
参数:
复杂语句
全局变量
局部变量
"""
a = 1
b = 2
# 复杂的语句,输出a,b的最大值
code = """
if a>b:
print(a)
else :
print(b)
"""
# 执行字符串,输出:2
exec(code)
# 使用全局变量 见到a替换成2,见到b替换成10 输出:10
exec(code, {'a': 2, 'b': 10})
# 同时使用全局变量和局部变量 两者同时存在且发生冲突,局部变量说的算...
# 输出:20
exec(code,{'a': 2, 'b': 10},{'a': 20, 'b': 10})
"""
表达式相当于孩子
全局变量相当于爸爸
局部变量相当于妈妈
爸爸在,听爸爸的话,妈妈在,听妈妈的话,爸爸妈妈同时在,优先听妈妈的话.....
"""
编译执行字符串格式的代码(compile)
"""
compile函数: 编译,类似编程语言的编译,
编译之后,下次使用的时候可以直接使用,不需要再次编译。
参数:
字符串格式的代码
文件对象
编译的源码类型 exec、eval、single
"""
# 代码
code = 'for i in range(0,10): print(i)'
# 方法一
# 执行code(实质上:先编译再执行)
exec(code)
# 方法二
# 先编译code
code = compile(code, '', 'exec')
# 再执行code
exec(code)
# 方法一和方法二达到的效果是一样的,方法二只需要一次编译,每次使用的时候都会编译一次
获得对象的类型(type)
# type函数:返回输入对象的类型
# type函数不考虑继承关系,也就是说,父亲和儿子是同一种类型
# 输出1的类型 输出:int
print(type(1))
判断两者的类型是否相同(isinstance)
# isinstance函数:判断两者的类型是否相同,考虑继承关系,父亲和儿子的类型不同。
# 输出1是否为int类型 输出:True
print(isinstance(1, int))
# 输出1是否为int、str其中的一个类型 输出:True
print(isinstance(1, (int, str)))
判断两者是否为父子关系(issubclass)
# issubclass函数:判断前者是否为后者的儿子
# 众所周知,bool类型继承int类型
# 输出:True
print(issubclass(bool, int))
求全部元素的总和(sum)
"""
sum函数:计算全部元素的总和
参数:
可迭代的列表
结果额外相加的数
"""
# 输出1-9相加的结果,结果最后再加上2 输出:47
print(sum(range(1, 10), 2))
留下某些符合条件的元素(filer)
# filter函数:留下一些符合条件的元素,结果True则留下。
# 奇数返回True、偶数返回False
def isOdd(x):
return x % 2 == 1
# 留下1-100的奇数
result = filter(isOdd, range(1, 101))
# 输出结果
print(list(result))
X的Y次方(pow)
# 输出2的3次方 结果:8
print(pow(2, 3))
# 输出2的三次方的结果进行%3 结果:2
print(pow(2, 3, 3))
转化为字节格式(bytes)
"""
bytes函数:1、如果第一个参数是字符串,后面必须要加上编码。把字符串转为十六进制的字节格式的字符串
2、如果第一个参数是数组、元组、集合,且所有元素的范围[0,255],把数组转为十六进制的字节格式的字符串
"""
# 第一个参数是字符串,输出:b'\xe4\xbd\xa0\xe5\xa5\xbd\xe5\x91\x80'
print(bytes('你好呀', encoding='utf-8'))
# str类型的encode和bytes函数的功能一样,都是把字符串按照某种编码转换为字节内容
# 输出:b'\xe4\xbd\xa0\xe5\xa5\xbd\xe5\x91\x80'
print('你好呀'.encode(encoding='utf-8'))
# 第一个参数是数组,输出:b'\xff\x02\x03'
print(bytes([255, 2, 3]))
转化为字节数组格式(bytesarray)
"""
bytearray:1、如果第一个参数是字符串,后面必须要加上编码。把字符串转为十六进制的字节格式的数组
2、如果第一个参数是数组、元组、集合,且所有元素的范围[0,255],把数组转为十六进制的字节格式的数组
"""
# 1、第一个参数为字符串,输出:bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd\xe5\x91\x80')
print(bytearray("你好呀", encoding='utf-8'))
# 2、第二个参数是数组,输出:bytearray(b'\x01\x02\x03')
print(bytearray([1, 2, 3]))
# bytes和bytearray最大的区别是,前者返回字符串,后者返回数组。
调用父类的函数(super)
class father:
def info(self):
print('我是父亲')
class B(father):
def add(self):
# 调用父亲的info函数
super().info()
print('我是儿子')
# 儿子实例化
b = B()
# 调用add函数
b.add()
"""
输出:
我是父亲
我是儿子
"""
检查一个对象是否可调用(callable)
# 输出int变量是否为可调用的 输出:False
print(callable(3))
# 输出abs函数是否为可调用的的 输出:True
print(callable(abs))
输出内容(print)
# 不输出到控制台,写入某个文件,生成日志文件。
# 打开文件
file = open('测试.txt', mode='a', encoding='utf-8')
# 写入文件,结尾加上\n
print('输出测试中', end='\n', file=file)
格式化(format)
"""
format函数:格式化
"""
# 1、对应位置的格式化 输出:旺财是狗
a = "{}是{}".format("旺财", "狗")
print(a)
# 2、指定位置的格式化(0代表第一个元素) 输出:旺财是狗
b = "{0}是{1}".format("旺财", "狗")
print(b)
# 3、key-value的格式化 输出:旺财是狗
c = "{a}是{b}".format(a='旺财', b='狗')
print(c)
# 4、通过字典进行格式化 输出:旺财是狗
d = {'a': '旺财', 'b': '狗'}
e = "{a}是{b}".format(**d)
print(e)
# 5、通过列表进行格式化 输出:旺财是(前面的0不可缺少)
f = ['旺财', '狗']
g = "{0[0]}是{0[1]}".format(f)
print(g)
# 6、数字的格式
# 保留小数点n位 这里是2位 输出:1.00
a = "{:.2f}".format(1)
print(a)
# 只保留整数 输出:1
a = "{:.0f}".format(1.23)
print(a)
# 设置数字总位数为n,位数不够,左边补零。 也可以补其他的字符,把0更换即可
# 输出:01
a = "{:0>2d}".format(1)
print(a)
# 设置数字总位数为n,位数不够,右边边补零。 也可以补其他的字符,把0更换即可
# 输出:10
a = "{:0<2d}".format(1)
print(a)
# 数字太大时,可以以逗号分割,类似银行的数字 输出:10,000,000
a = "{:,}".format(10000000)
print(a)
# 百分比 保留小数点后2位 输出:30.00%
a = "{:.2%}".format(0.30)
print(a)
# 转化数字为对应的进制
# 二进制 输出:10011
a = '{:b}'.format(19)
print(a)
# 十进制 输出:19
a = '{:d}'.format(19)
print(a)
# 八进制 输出:23
a = '{:o}'.format(19)
print(a)
# 十六进制 输出:13
a = '{:x}'.format(19)
print(a)
获取全部元素的个数(len)
# 输出数组元素的个数 输出:3
print(len([1, 2, 3]))
获取、设置、删除类的属性(property)
class A:
# 构造函数,name属性
def __init__(self, name):
self.name = name
# 获得name属性
def getName(self):
return self.name
# 设置name属性
def setName(self, name):
self.name = name
# 删除name属性
def delName(self):
del self.name
# 把属性name的set、get、del权限都放在propertyName
propertyName = property(getName, setName, delName)
# 实例化A
a = A('小明')
# 获得name属性 可以进行get、set、del(删除)
# get属性
print(a.propertyName)
# set属性
a.propertyName = '小红'
# del属性
del a.propertyName
冻结的集合(frozentset)
# frozenset不能添加或删除任何元素
# 输出frozenset集合 输出:frozenset({1, 2, 3, 4, 5, 6, 7, 8, 9})
print(frozenset(range(1, 10)))
# set和frozenset有点像list和tuple之间的关系
获取对象的属性和值(vars)
# vars函数:获取对象的属性和对应的值 如果不写参数,使用当前位置作为对象
print(vars())
获取当前位置的局部变量(locals)
# 获取当前位置的局部变量
print(locals())
获取当前位置的全局变量(globals)
# 获取当前位置的全局变量
print(globals())
获取对象的解释器形式
# 输出a的解释器形式,相当于是输出说明书
a = ['1', '2']
print(repr(a))
颠倒前后元素(reversed)
# 颠倒a的前后元素排列顺序 输出:[4, 3, 2, 1]
a = [1,2,3,4]
print(list(reversed(a)))
动态导入模块(import)
# 动态导入sys模块
__import__('sys')
获取一个对象的hash值(hash)
# 输出a的hash值
a = '珍惜眼前人'
# 输出:8210466439863847528
print(hash(a))