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
2range（1,3,2）即：从1到3，每次增加2，因为1+2=3，所以输出只有1
第三个数字2是代表步长。如果不设置，就是默认步长为1
>>> for i in range(1,3,2):
print(i)
12.Python数字函数
函数 | 返回值（描述） |
abs(x) | 返回数字的绝对值，如abs（-10）返回10 |
ceil（x） | 返回数字的上入整数，如math.ceil（4.1）返回5 |
cmp(x,y) | 如果 x < y 返回 -1，如果x == y 返回0，如果x > y 返回1 |
exp（x） | 返回e的x次幂（ex），如果math.exp（1）返回2.718281828459045） |
fabs(x) | 返回数字的绝对值，如math.fabs（-10）返回10.0 |
floor（x） | 返回数字的下设整数，如math.floor（4，9）返回4 |
log（x） | log() 返回 x 的自然对数，如math.log（math.e）返回1.0，math.log(100，10)返回2.0 |
log10(x) | 返回以10为基数的x的对数，如math.log10(100)返回2.0 |
max(x1,x2,…) | 返回给定参数的最大值，参数可以为序列 |
min（x1,x2,…） | 返回给定参数的最小值，参数可以为序列 |
modf(x) | 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示 |
pow(x,y) | x**y运算后的结果 |
round(x,[n]) | 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数 |
sqrt(x) | 返回数字x的平方根 |
3.Python随机函数
随机数可以用于数字，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性；
Python包含以下常用随机函数：
函数 | 描述 |
choice（）seq | 从序列的元素中随机挑选一个元素，比如random.choice（range(10)）,从0到9中随机挑选一个整数 |
randrange（[start,] stop [,step]） | 从指定基数递增的集合中获取一个随机数，基数默认值为1 |
random（） | 随机生成一个实数，它在[0,1）范围内 |
seed（[x]） | 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed |
shuffle(lst) | 将序列的所有元素随机排列 |
unifrom(x,y) | 随机生成下一个实数，它在[x,y]范围内 |
4.Python的字符串内建函数
字符串方法是从python1.6到2.0慢慢加进来的——它们也被加到了Python中；
这些实现了string模块的大部分方法，如下表所示除了目前字符串内建支持的方法，都包含了对Unicode的支持，有一些甚至是专门用于Unicode的。
方法 | 描述 |
string.capitalize() | 把字符串的第一个字符大写 |
string.center(width) | 返回一个原字符串居中，并使用空格填充至长度width的新字符串 |
string.count(str, beg=0, end=len(string)) | 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
string.decode(encoding=‘UTF-8’, errors=‘strict’) | 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 ‘ignore’ 或 者’replace’ |
string.encode(encoding=‘UTF-8’, errors=‘strict’) | 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’ |
string.endswith(obj, beg=0, end=len(string)) | 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. |
string.expandtabs(tabsize=8) | 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 |
string.find(str, beg=0, end=len(string)) | 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 |
string.format() | 格式化字符串 |
string.index(str, beg=0, end=len(string)) | 跟find()方法一样，只不过如果str不在 string中会报一个异常. |
string.isalnum() | 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False |
string.isalpha() | 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False |
string.isdecimal() | 如果 string 只包含十进制数字则返回 True 否则返回 False. |
string.isdigit() | 如果 string 只包含数字则返回 True 否则返回 False. |
string.islower() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
string.isnumeric() | 如果 string 中只包含数字字符，则返回 True，否则返回 False |
string.isspace() | 如果 string 中只包含空格，则返回 True，否则返回 False. |
string.istitle() | 如果 string 是标题化的(见 title())则返回 True，否则返回 False |
string.isupper() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
string.join(seq) | 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
string.ljust(width) | 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 |
string.lower() | 转换 string 中所有大写字符为小写. |
string.lstrip() | 截掉 string 左边的空格 |
string.maketrans(intab, outtab) | maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
max(str) | 返回字符串 str 中最大的字母。 |
min(str) | 返回字符串 str 中最小的字母。 |
string.partition(str) | 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. |
string.replace(str1, str2, num=string.count(str1)) | 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. |
string.rfind(str, beg=0,end=len(string) ) | 类似于 find() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。 |
string.rindex( str, beg=0,end=len(string)) | 类似于 index()，不过是返回最后一个匹配到的子字符串的索引号。 |
string.rjust(width) | 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 |
string.rpartition(str) | 类似于 partition()函数,不过是从右边开始查找 |
string.rstrip() | 删除 string 字符串末尾的空格. |
string.split(str=“”, num=string.count(str)) | 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串 |
string.splitlines([keepends]) | 按照行(‘\r’, ‘\r\n’, ‘\n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
string.startswith(obj, beg=0,end=len(string)) | 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. |
string.strip([obj]) | 在 string 上执行 lstrip()和 rstrip() |
string.swapcase() | 翻转 string 中的大小写 |
string.title() | 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
string.translate(str, del=“”) | 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中 |
string.upper() | 转换 string 中的小写字母为大 |
string.zfill(width) | 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0 |
5.文件操作函数
序号 | 方法及描述 |
1 | file.close()关闭文件。关闭后文件不能再进行读写操作。 |
2 | file.flush()刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。 |
3 | file.fileno()返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。 |
4 | file.isatty()如果文件连接到一个终端设备返回 True，否则返回 False。 |
5 | file.next()返回文件下一行。 |
6 | file.read([size])从文件读取指定的字节数，如果未给定或为负则读取所有。 |
7 | file.readline([size])读取整行，包括 “\n” 字符。 |
8 | file.readlines([sizeint])读取所有行并返回列表，若给定sizeint>0，则是设置一次读多少字节，这是为了减轻读取压力。 |
9 | file.seek(offset[, whence])设置文件当前位置 |
10 | file.tell()返回文件当前位置。 |
11 | file.truncate([size])截取文件，截取的字节通过size指定，默认为当前文件位置。 |
12 | file.write(str)将字符串写入文件，返回的是写入的字符长度。 |
13 | file.writelines(sequence)向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。 |
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)各个参数的细节如下：
- 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.seek函数
seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。
1.tell函数
tell()方法告诉你文件内的当前位置, 换句话说，下一次的读写会发生在文件开头这么多字节之后。
2.write函数
write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符(‘\n’)：
1.read函数
read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
语法：
fileObject.read([count])在这里，被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入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()open函数中mode 参数有：
模式 | 描述 |
t | 文本模式 (默认)。 |
x | 写模式，新建一个文件，如果该文件已存在则会报错。 |
b | 二进制模式。 |
+ | 打开一个文件进行更新(可读可写)。 |
U | 通用换行模式（不推荐）。 |
r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 |
r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 |
w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
w+ | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
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, 'one'), (2, 'two'), (3, 'three')]
num: (1, 2, 3)
str: ('one', 'two', 'three')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))结果：
{('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')
he8.python中的round()函数
round()
round()是python自带的一个函数，用于数字的四舍五入。
round(number,digits)参数：
- 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； 311.python中的strip()函数
返回删除前导和尾随空格的字符串副本。如果给定了chars而不是None，则删除chars中的字符。（该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。）
第一种：strip()当函数体内不存在任何的字符的时候则返回的是删除字符串前导和尾随空格的字符串副本(一般用来去除前后的空格)
第二种：strip()当函数体内存在字符的时候则得到的是删除字符串头尾相应字符的字符串副本
a = “abcdef123456cba”
print(a.strip(“abc”))
>>> def12345612.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 ) 将一个整数转换为一个八进制字符串13.hasattr() 函数用于判断对象是否包含对应的属性。
hasattr(object, name)
object -- 对象。
name -- 字符串，属性名。
return
如果对象有该属性返回 True，否则返回 False。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)))结果为：
['B', 'E']
['a', 'c', 'd']例子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}]例子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’]15.isinstance() 内置函数
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
sinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
1、原型
isinstance(object, classinfo)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]
