Python中的常用函数_python 函数

1.range()是一个函数

for i in range () 就是给i赋值：

比如 for i in range （1，3）：

就是把1,2依次赋值给i

range () 函数的使用是这样的:

range(start, stop[, step])，分别是起始、终止和步长

举例：

range（3）即：从0到3，不包含3，即0,1,2

>>> for i in range(3):
	print(i)
 
0
1
2
1
2
3
4
5
6

range（1,3,2）即：从1到3，每次增加2，因为1+2=3，所以输出只有1

第三个数字2是代表步长。如果不设置，就是默认步长为1

>>> for i in range(1,3,2):
	print(i)
 
1
1
2
3
4

---

2.Python数字函数

---

3.Python随机函数

随机数可以用于数字，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性；
Python包含以下常用随机函数：

---

4.Python的字符串内建函数

字符串方法是从python1.6到2.0慢慢加进来的——它们也被加到了Python中；
这些实现了string模块的大部分方法，如下表所示除了目前字符串内建支持的方法，都包含了对Unicode的支持，有一些甚至是专门用于Unicode的。

---

5.文件操作函数

1.open函数
语法：

file object = open(file_name [, access_mode][, buffering])
//完整版
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
1
2
3
4

各个参数的细节如下：

• file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
• access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。
• buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
• encoding: 一般使用utf8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型
• opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。
  1.close函数
  File 对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。

当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。用 close（）方法关闭文件是一个很好的习惯。

语法：

fileObject.close()
1

1.seek函数

seek（offset [,from]）
1

方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。

如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。

1.tell函数
tell()方法告诉你文件内的当前位置, 换句话说，下一次的读写会发生在文件开头这么多字节之后。

2.write函数
write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。

write()方法不会在字符串的结尾添加换行符(‘\n’)：

1.read函数
read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。

语法：

fileObject.read([count])
1

在这里，被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。

举例：

fo = open("test.txt",'r+')
print("fo->name:%s,fo->mode:%s"%(fo.name,fo.mode))
fo.write("this is my test.")
 
str = fo.read(5)
print("first read:%s"%str)
#查找当前位置
print("当前位置:",fo.tell())
fo.seek(0,0)
print("当前位置：",fo.tell())
print("str:",fo.read(20))
fo.close()
1
2
3
4
5
6
7
8
9
10
11
12

open函数中mode 参数有：

---

6、zip函数

对于我们的两个list，a和b，list(zip(a, b))生成了一个列表。在这个列表中，每个元素是一个tuple；对于第i个元组，它其中的内容是(a[i-1], b[i-1])。这样的操作，与压缩软件的“压缩”十分接近。如果我们继续在zip()中加入更多的参数，比如zip(a, b, c, d)，那么在将它转换成list之后，结果当然就是[(a[0], b[0], c[0], d[0]), (a[1], b[1], c[1], d[1]), …, (a[n-1], b[n-1], c[n-1], d[n-1])]。

事实上，在 Python 3 中，为了节省空间，zip()返回的是一个tuple的迭代器，这也是我们为什么要调用list()将它强制转换成list的原因。不过，Python 2中，它直接返回的就是一个列表了。

如果我们传入zip()中的几个参数不等长，会有什么结果呢？zip()很灵活，如果几个参数不等长，那么它会取最短的那个参数的长度，然后再进行处理。至于那些超出最短长度的成员，就只好被舍弃掉了。

origin = zip(result) #前面加号，事实上*号也是一个特殊的运算符，叫解包运算符

例子：

numbers = [ 1, 2, 3]
string = [ 'one','two','three']
result = zip(numbers,string)
lresult = list(result)
print(set(result))
 
print(lresult)
c,v = zip(*lresult)
print('num:', c)
print("str:", v)
1
2
3
4
5
6
7
8
9
10

结果：

[(1, 'one'), (2, 'two'), (3, 'three')]
num: (1, 2, 3)
str: ('one', 'two', 'three')
1
2
3

7、python内置函数set

• set函数返回值：一个 set object （集合对象，即 一个 “无序不重复元素集”，特点 ：无序，不重复）
• 参数：空 或者 一个可迭代对象。
  特性一：不重复。可以十分方便的实现一个去重的目的。当然，我们也可以将set对象转化为其它的可迭代对象。

特性二：无序。对于无序的可迭代对象，不能通过索引的方式取值。

set对象内置方法：

1.add 即：添加一个元素进入集合，当此元素存在时， 无影响（啥也不做）。
2.clear 即：将集合中所有元素移除（变为空集合）
3.copy 即：返回一个集合的浅拷贝
4.difference 即：将两个和或多个集合进行比较，返回一个新集合，这个集合中的元素存在于**第一个集合（或调用这个方法的集合）中，但不存在于其它集合中。
5.difference_update 即：从第一个集合(或调用这个方法的集合)中移除所有属于其它集合但不属于第一个集合(或调用这个方法的集合)**的所有元素。需要特别注意的是，这个方法返回值并不是一个新集合。
6.remove() 即：清除一个元素可以用 remove 或者 discard, 而清除全部可以用 clear.
7.difference() 即：进行一些筛选操作, 比如对比另一个东西, 看看原来的 set 里有没有和他不同的 (difference).

编写一个函数来查找字符串数组中的最长公共前缀

strs = ['hello','helool','heool']
lst = list(strs)
def longestCommonPrefix(strs):
    result = ""
    print(set(zip(*strs)))
    for temp in zip(*strs):
        print("tmp:",temp)
        if len(set(temp)) == 1:
            result += temp[0]
        else:
            break
    return result
 
print( longestCommonPrefix(lst))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

结果：

{('e', 'e', 'e'), ('o', 'o', 'l'), ('h', 'h', 'h'), ('l', 'o', 'o'), ('l', 'l', 'o')}
tmp: ('h', 'h', 'h')
tmp: ('e', 'e', 'e')
tmp: ('l', 'l', 'o')
he
1
2
3
4
5

---

8.python中的round()函数

round()
 
round()是python自带的一个函数，用于数字的四舍五入。
 
round(number,digits)
1
2
3
4
5

参数：

• digits>0，四舍五入到指定的小数位
• digits=0, 四舍五入到最接近的整数
• digits<0 ，在小数点左侧进行四舍五入
• 如果round()函数只有number这个参数，等同于digits=0

四舍五入规则：

• 要求保留位数的后一位<=4，则进位，如round(5.214,2)保留小数点后两位，结果是 5.21
• 要求保留位数的后一位“=5”，且该位数后面没有数字，则不进位，如round(5.215,2)，结果为5.21
• 要求保留位数的后一位“=5”，且该位数后面有数字，则进位，如round(5.2151,2)，结果为5.22
• 要求保留位数的后一位“>=6”，则进位。如round(5.216,2)，结果为5.22

---

9.字典中setdefault函数

在setdefault函数使用时，如果不指定value，默认的value就是None（None在Python中也是一个对象，记住Python中一切都是对象，Python支持动态类型变换）。

setdefault函数的设计思想，设置key对应的默认值，如果key存在，key对应的value不会被改变，而且函数总是返回key的默认值。

在setdefault之后，dict类型的对象就有了index（key），然后就可以直接通过index来修改对应的value。或者直接通过index（key），可以增加dict对象中的key-value pairs。

字典常用函数/操作：

---

10、python中items函数

items:函数以列表返回可遍历的(键, 值) 元组数组常与for循环搭配

//例如
a={'a':1,'b':2,'c':3}
print(a.items())
for key,value in a.items():
    print("key:",key)
    print('value；',value)
//输出
dict_items([('a', 1), ('b', 2), ('c', 3)])
key: a
value； 1
key: b
value； 2
key: c
value； 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

11.python中的strip()函数

返回删除前导和尾随空格的字符串副本。如果给定了chars而不是None，则删除chars中的字符。（该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。）

第一种：strip()当函数体内不存在任何的字符的时候则返回的是删除字符串前导和尾随空格的字符串副本(一般用来去除前后的空格)

第二种：strip()当函数体内存在字符的时候则得到的是删除字符串头尾相应字符的字符串副本

a = “abcdef123456cba”
print(a.strip(“abc”))
>>> def123456
1
2
3

---

12.python中数字与字符的转换

int(x ) 将x转换为一个整数
long(x) 将x转换为一个长整数
float(x ) 将x转换到一个浮点数
complex(real [,imag ]) 创建一个复数
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s ) 将序列 s 转换为一个元组
list(s ) 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个字符
unichr(x ) 将一个整数转换为Unicode字符
ord(x ) 将一个字符转换为它的整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串
1
2
3
4
5
6
7
8
9
10
11
12
13
14

13.hasattr() 函数用于判断对象是否包含对应的属性。

hasattr(object, name)
object -- 对象。
name -- 字符串，属性名。
return
如果对象有该属性返回 True，否则返回 False。
1
2
3
4
5

---

14. filter() 函数

(1)、filter()函数的简介和语法：

filter()函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新列表。

(2)、filter()语法如下：

filter(function,iterable)

function – 判断函数。

iterable – 可迭代对象

序列中的每个元素作为参数传递给函数进行判断， 返回True或者False，最后将返回True的元素放到新列表中

(3)、filter()使用举例

栗子1： 过滤掉列表当中的数字0

list_num = [1, 2, 3, 0, 8, 0, 3]
print(list(filter(lambda x: x, list_num)))

结果为：
[1, 2, 3, 8, 3]
栗子2：过滤列表中数字的大小写(针对的是字母全都是大写或小写的情况)

list_word = ['a', 'B', 'c', 'd', 'E']
print(list(filter(lambda x: x.isupper(), list_word)))
print(list(filter(lambda x: x.islower(), list_word)))
1
2
3

结果为：

['B', 'E']
['a', 'c', 'd']
1
2

例子3：与dict构成的列表处理例子

dict_a = [{'name': 'python', 'points': 10}, {'name': 'java', 'points': 8}]
test_filter = filter(lambda x : x['name'] == 'python', dict_a)
print(list(test_filter))
 
输出结果：
[{'name': 'python', 'points': 10}]
1
2
3
4
5
6

例子4：去除空格字符

b = ['\n    ', '1', '  ','Tuesday, May 05, 2020','\n',None]
 
def not_empty(s):
    return s and s.strip()
c = filter(not_empty,b)
print(list(c))
结果：
[‘1’, ‘Tuesday, May 05, 2020’]
1
2
3
4
5
6
7
8

---

15.isinstance() 内置函数

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

sinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

1、原型

isinstance(object, classinfo)
1

2、参数

object – 实例对象。 classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。

3、返回值

如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。

实例：（获取嵌套的数组列表）

def flatten(nest_list:list):
    out = []
    for i in nest_list:
        if isinstance(i, list):
            tmp_list = flatten(i)
            for j in tmp_list:
                out.append(j)
        else:
            out.append(i)
    return out
    
    
    
测试结果：

a = [[1,2], ['a','b', [3, 4]]]
b = flatten(a)
print(b)
# 输出： [1, 2, 'a', 'b', 3, 4]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

---