python内置函数

吾之最爱（你在和影子玩拳击吗？）

常用Python内置函数

 

1、isinstance  判断变量的数据类型

 

temp = "asdfsdfs"  
  
r = isinstance(temp, list)  
  
print(r)  

案例：

 

2、

python函数传参的时候是传引用 ----新浪面试题

      不可变类型是值传递，比如元组，数字，字符串
      可变类型就是引用，比如list，dict等

java，c#等是在ref out在内存中在创建一份值

 

3、lambda用法：

 

def f1():  
  
    return 123  
  
f2 = lambda :123  
  
r1 = f1()  
  
r2 = f2()  
  
print(r1,r2) 

案例：

def f3(a1,a2):  
  
    return a1 + a2  
  
f4 = lambda a1,a2: a1 + a2  
  
r3 = f3(1,2)  
  
r4 = f4(3,4)  
  
print(r3,r4) 

方法2：

1、abs--取绝对值

i = abs(123)  
  
print(i)  
  
i = abs(-123)  
  
print(123)  

案例：

2、all 循环参数，如果每个元素都为真，那么all的返回值都为真

由于判断真的太多，所以判断假的就可以了  
  
i =all(["",(),{},0,None,"123",])  
  
print(i)  
  
结果：False  

案例：

3、any  只要有一个为真，则为真

i =any(["",None,(),{},123])  
  
print(i)  
  
结果：False

案例：

4、

bin()  # 二进制  
  
oct()  #八进制  
  
int()   #十进制  
  
hex()  #十六进制  

i = int('0b11',base=2)  
  
print(i)  
  
i = int('11',base=8)  
  
print(i)  
  
i = int('0xe',base=1t6)  
  
print(i)  

案例：

5、chr 和 ord和bytes

首先字符串转字节  
  
bytes("xxxx",encoding="utf-8")  
  
其次  
  
c = chr(65)  返回数值表达式值为编码的字符  
  
print(c)  
  
在其次  
  
                  ---将ASCLL码值转换为字符  
  
d = ord("a")  ---必须是字符串才可以  
  
print(d)  

案例

6、callable检查对象object是否可以调用

f1 = 123  
  
r = callable(f1)  

案例

7、dir  查看类型的帮助文档方式

help()效果一样  
  
li = []  
  
print(dir(li))

案例

8、divmod  除商得余数---例如分页

a = 10 / 3  
  
print(a)  
  
r = divmod(10,3)  
  
print(r)  
  
结果:  
  
3.33333335  
  
(3,1)  

案例：

1 )、math.ceil(i)  #这个方法对i向上取整，i = 1.3 ，返回值为2
2 )、math.floor(i)  #正好与上面相反，是向下取整。i = 1.4，返回1
3 )、math.pow(a, b)  # 返回a的b次方
4 )、math.sqrt(i)  #返回i的平方根

5) .  math模块处理正号和负号math.fabs(-1.1)   得到1.1

6). 圆周率π : math.pi

 

9、eval  -----强制不转换输入类型的格式

ret = eval("1 + 3")  
  
print(ret)  
  
结果：4 

案例

10、exec ----执行py代码---没有返回值

exec("for i inrange(10): print(i)")  
  
结果：  
  
0  
  
1  
  
2  
  
3  
  
4......  

案例

 11、filter （过滤）

def f1(x):  
  
    if x > 22:  
  
       return True  
  
    else:  
  
       return False  
  
    ---------------  
  
    return x > 22 -----------第二种简写方法  
  
ret = filter(f1,[11,22,33,44])  

案例一

ret = filter(lambda x: x >22, [11,22,33,44])  
  
for i in ret:  
  
    print(i) 

lambda写法

12、map  无论是map还是filter，得到的结果都是可迭代的对象，迭代器的实例

区别在于， map是根据值返回true和false， 而filter是跟true和false返回值

def f1(x):  
  
    if x % 2 == 1:  
  
       return x + 100  
  
    else:  
  
       return x  
  
ret = map(f1, [1,2,3,4,5])  
  
ret2 = map(lambda x: x + 100if x % 2 == 1 else x ,[1,2,3,4,5])  
  
print(ret)  
  
for i in ret :  
  
    print(i)  

案例一

def comp(y):  
  
    c = y > 11  
  
    return c  
  
ret1 = map(comp, [1,2,4,11,22, 33])  
  
for i in ret1:  
  
    print(i)  

filter和map区别

# ret2 =filter(comp,[1,2,4,11, 22, 33])  
  
# for i in ret2:  
  
#     print(i)  

filter

13、max()最大数 min()  最小数

li = [11,22,123,1]  
  
r = max(li)  
  
print(r)  
  
a = min(li)  
  
print(a) 

案例

14、iter 迭代器  next输出迭代器的下一个元素

obj =iter([11,22,33,44])   创建迭代器对象  
  
print(obj)  
  
r1 = next(obj)   输入迭代器的下一个元素  
  
print(r1)  
  
r2 = next(obj)  
  
print(r2)  

案例

15、pow(x,y) ----就是求x的y次方

i = pow(2,100)  
  
print(i)  

案例

16、zip ---意思就是取两个变量中索引相对应的值，，个人理解

li1 = [11,22,33,44]  
  
li2 =["a",'VV',"c","E"]  
  
r = zip(li1,li2)  
  
print(r)  
  
for i in r :  
  
    print(i) 

案例

17、globals  locals

声明全局变量和局部变量

a = 1  
  
def f(x):  
  
    global a  
  
    a = 2  
  
    c = x + a  
  
    print(c)  
  
f(3)  
  
print(a) 

案例

18、round用法---返回浮点数x的四舍五入值

round(80.2332434, 2)  
  
结果：80.23  

案例

19、open函数的应用

(1).def close(self,*args,**kwargs)关闭文件

(2).def fileno(self,*args,**kwargs) 文件描述符

(3).def flush(self,*args,**kwargs) 刷新文件内部缓冲区（就是可以写入磁盘）

f = open("ha1.log",'w')  
  
f.write(bytes("不穿",encoding:utf-8))  
  
f.flush()  先注销这句，然后知行，用下面代码查看，然后再     
  
input("adf:")   用这句上flush这句在看，  

View Code

with open("ha1.log",'r') as f:  
  
    a = f.read()  
  
    print(a)  

常用方式-我最喜欢的方式

(4).def isatty(self,*args,**kwargs) 判断文件是否是同意tty设备

(5)def read(self,*args,**kwargs)读取指定字节数据

(6)def readable(self,*args,**kwargs)是否可读

with open("ha1.log",'r') as f:  
  
    a = f.readable()  
  
    print(a)  

(7)def readline(self,*args,**kwargs)仅读取一行数据

with  open("ha1.log",'r',encoding="utf-8") as f:  ----注意这个地方要写字符集编码  
  
    f.seek(0)  
  
    a = f.readline()  
  
    print(a)  

(8)def seek(self,*args,**kwargs)指定文件中指针位置

(9)def seekable(self,*args,**kwargs)指针是否可操作

(10)def tell(self,*args,**kwargs)获取指针位置

(11)def truncate(self,*args,**kwargs)截取数据，进保留之前数据(3.5以后会先保存在内存中，2.7则会删除)

line = fo.readline()  
  
print ("Read Line:%s" % (line))  
  
print(fo.tell())  
  
   
  
# Now truncate remainingfile.  
  
fo.truncate(8)  
  
fo1 =open("foo.txt", "w")  
  
   
  
line = fo.readlines()  
  
print(fo.tell())  
  
print ("Read Line:%s" % (line))  

(12)def writable(self,*args,**kwargs)是否可写

(13)def write(self,*args,**kwargs)写内容

20、open---打开，关闭，close

模式    描述
r    打开一个文件为只读。文件指针被放置在文件的开头。这是默认模式。
rb    打开一个文件只能以二进制格式读取。文件指针被放置在文件的开头。这是默认模式。
r+    打开用于读和写文件。文件指针置于该文件的开头。
rb+    打开用于读取和写入二进制格式的文件。文件指针置于该文件的开头。
w    打开一个文件只写。如果文件存在覆盖该文件。如果该文件不存在，则创建写入新文件。
wb    打开一个文件只能以二进制格式写入。如果文件存在覆盖该文件。如果该文件不存在，则创建写入新文件。
w+    打开文件为写入和读取模式。如果文件存在覆盖现有文件。如果该文件不存在，创建用于读写操作的新文件。
wb+    打开用于以二进制格式写入和读出文件。如果文件存在覆盖现有文件。如果该文件不存在，创建用于读写操作的新文件。
a    打开用于追加的文件。文件指针是在文件是否存在该文件的末尾。也就是说，该文件是在追加模式。如果该文件不存在，它会创建一个用于写入的新文件。
ab    打开文件用于二进制格式追加。文件指针是在文件是否存在该文件的末尾。也就是说，文件是在追加模式。 如果该文件不存在，它会创建一个用于写入的新文件。
a+    打开文件为追加和读取方式。文件指针是在文件是否存在该文件的末尾。该文件以追加模式打开。如果该文件不存在，它将创建用于读写操作的新文件。
ab+    打开一个文件以附加和二进制格式读取模式。如果该文件存在文件指针在该文件的末尾。该文件以追加模式打开。如果该文件不存在，它将创建读写操作的新文件。

r, w, a等区别一目了然

 

（1）、只读，r

f = open("路径文件"，"r")  
  
f.write("asdfasdf")  
  
f.close()

案例

（2）、w只写模式【不可读；文件不存在则创建；存在则清空内容】

f =open("ha1.log",'a')  
  
a1 = f.tell()  ---查看指针位置  
  
print(a1)  
  
f.write("nini")  ----如果文件存在清空后出现”nini“  
  
   
  
a = f.tell()----在查看指针  
  
print(a)  
  
f.seek(0)  
  
#c = f.read()  ----不可读  
  
#print(c)  
  
f.close()  -----------关闭  
  
#print(c)  

案例

（3）、x 不可读，不存在则创建，存在则报错

f =open("ha3.log",'x')  
  
a1 = f.tell()  
  
print(a1)  
  
f.write("nini")  
  
   
  
a = f.tell()  
  
print(a)  
  
f.seek(0)  
  
#c = f.read()  ---=不可读  
  
   
  
#print(c)  
  
f.close()  

案例

（4）、a 不可读，不存在则创建，存在则只追加

f =open("ha3.log",'a')  
  
a1 = f.tell()  
  
print(a1)  
  
f.write("cccc")-----上面已经写入了"nini " ,存在则只追加内容  
  
a = f.tell()  
  
print(a)  
  
f.seek(0)  
  
#c = f.read()  
  
#print(c)  
  
f.close() 

案例

 

 

（1）、r+ 如果文件不存在无法自动创建写入，而且主意字节转换

f =open("ha3.log",'r+',encoding="utf-8")   --------注意文件和编码  
  
a1 = f.tell()  
  
print(a1)  
  
f.read()  
  
# print(a2)  
  
a3 = f.tell()  
  
print(a3)  
  
f.write("我吃了午饭")  
  
   
  
a = f.tell()  
  
print(a)  
  
#f.seek(0)  
  
#c = f.read()  
  
   
  
#print(c)  
  
f.close()  

案例

（2）、w+ ，如果文件存在则清空，如果不存在则创建

f =open("ha3.log",'w+',encoding="utf-8")  
  
a1 = f.tell()  
  
print(a1)  
  
f.read()  
  
# print(a2)  
  
a3 = f.tell()  
  
print(a3)  
  
f.write("我没吃午饭吗？")  
  
   
  
a = f.tell()  
  
print(a)  
  
f.seek(0)  
  
c = f.read()  
  
   
  
#print(c)  
  
f.close()  

案例

（3）、x+  存在则报错 ，就不测试了

（4）、a+  不存在则创建，存在则末尾追加

 

（1）、rb  现在自动转换成了返回的二进制的值，用16进制表示

f =open("ha3.log",'rb')  
  
a1 = f.tell()  
  
print(a1)  
  
a = f.read()  
  
print(str(a,ending="utf-8")) ----------转换的时候，需要str，然后再给参数。这是需要注意的地方  
  
a2 = f.tell()  
  
print(a2)  
  
f.close()  

案例-重点

（2）、wb 不可读

f =open("ha3.log",'wb')  
  
a1 = f.tell()  
  
print(a1)  
  
f.write(bytes("啦啦啦啦",encoding="utf-8"))  
  
a2 = f.tell()  
  
print(a2)  
  
f.close()  

案例

（3）xb

（4）ab

 为了避免打开后忘了关闭，可以通过管理上下文，即：

with open("log",'r'，encoding="utf-8) as f ,open("log2","w",encoding="utf-8") as f2:  
  
     for line in f1:  
  
            f2.write(line) 

在python2.7之后，with又支持同时对多个文件的上下文进行管理