Python常用函数

1.常用函数

#input ()

• 交互式输入格式
• 获取的内容都是字符串

name = input('请输入你的姓名：') 

#upper()

• 全部大写

s1 = 'taiBAi'
print(s1.upper())  >>>>>TAIBAI

#lower()

• 全部小写

  s1 = 'taiBAi'
  print(s1.lower()) >>>>taibai
  

#range()

• 范围，通过range达到循环数字
• 是一个可迭代对象

a = range(9)
print(a)
>>>>>range(0, 9)

• 顾头不顾腚

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

• 步长
• 必须要有起始位置值和终止位置值和步长值

for i in range(1,7,2):
    print(i)
>>>>1 3 5
for i in range(2,-2,-1):
    print(i)
>>>>2 1 0 -1

a = range(0,5)   
	print(a)
Pyrhon2中返回的结果是：	[0,1,2,3,4]
Python3中返回的结果是：	(0,5)

#copy()

• 浅copy 例：l2 = l1.copy()
• 深copu.deepcopy() 例： l2 = copy.deepcopy(l1)

#enumerate()

• 枚举，得到一个可迭代对象
• 对元组里的每一个元素添加序号

l1 = ("a", "b", "c")
for i in enumerate(l1):
    print(i)
 >>>>>(0, 'a')
      (1, 'b')
      (2, 'c')

#format()

• 通过 {} 和 : 来代替以前的 %

print ("{} {}".format("hello", "world"))
>>>hello world  ###不设定指定位置，默认排序
print ("{0} {1} {0}".format("hello", "world"))
>>>hello world hello ###按照索引指定位置
s = "alex{a}wu{c}si{b}r"
s1 = s.format(b="你好",a="我好",c="大家好")    # 按照关键字格式化
print(s1)
>>>alex我好wu大家好si你好r

#strip()

• 移除字符串头尾指定的字符（默认为空格）

name = "   aleX leNb   "
print(name.strip()) >>>>aleX leNb
name1 = "00000alex0000"
print(name1.strip('0')) >>>>>alex

#split ()

• 从左向右寻找，以某个元素为中心将左右分割成两个元素并放入列表中
• 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串
• 默认为所有的空字符，包括空格、换行( )、制表符( )等

a = "alex:alex123"
print(a.split(":"))  >>>>['alex', 'alex123']        
print(a.split("l",1))  >>>>['a','lexalex123'] 
print(a.split(":")[0])   >>>>alex
print(a.split(":")[1])   >>>>alex123

rsplit()

• 从右向左寻找，以某个元素为中心将左右分割成两个元素并放入列表中
• 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串
• 默认为所有的空字符，包括空格、换行( )、制表符( )等

b = "dlrblist"
b1 = b.rsplit("l", 1)
print(b1)  #['dlrb', 'ist']

b = "dlrblist"
b2 = b.rsplit("l", 2)
print(b2)  #['d', 'rb', 'ist']

#splitlines()

• 根据换行符（ ）分割并将元素放入列表中

c = "hello
world
dlrb"
c1 = c.splitlines()
print(c1)  #['hello', 'world', 'dlrb']

#capitalize()

• 首字母大写其余变小写

  s1 = 'taiBAi'
  print(s1.capitalize())
  >>>>Taibai
  

#swapcase()

• 大小写翻转

  s1 = 'taiBAi'
  print(s1.capitalize())
  >>>>TAIbaI
  

#title()

• 每个单词的首字母大写

  s1 = 'tai2BAi'
  print(s1.capitalize())
  >>>>Tai2Bai
  

#center()

• 居中

  s1 = 'tai2BAi'
  print(s1.center(20))
  >>>>      tai2BAi       
  print(s1.center(20,'*'))
  >>>>******tai2BAi*******
  
  
  

#find()

• 通过找元素索引，找到第一个就返回，找不到-1

  s1 = 'tai2BAi'
  print(s1.find('a'))  >>> 1
  print(s1.find('c'))  >>> -1
  
  

#count()

• 获取某元素在列表中出现的次数

  li = (1, 3, 1, "a", 1, "a", 5, "c")
  print(li.count(1))   >>> 3
  print(li.count('a'))   >>> 2
  
  

#index()

• 通过元素的名称获取元素的索引

  li = (1, 3, 1, "a", 1, "a", 5, "c")
  print(li.index('c'))  >>> 7
  print(li.index(1))  >>> 0
  
  

#type()

• 查看数据类型

  a = "坚持"
  print(type(a))  >>>> <class 'str'>
  a = 4
  print(type(a))  >>>> <class 'int'>
  
  

#float()

• 用于将整数和字符串转换成浮点数

  >>>float(1)
  1.0
  >>> float(112)
  112.0
  >>> float(-123.6)
  -123.6
  >>> float('123')     # 字符串
  123.0
  
  

#sort()

• 在源列表对元素进行排序

  l1 = [44, 55, 66, 33, 22]
  l1.sort()
  print(l1)     >>>> [1, 1, 2, 3, 4, 5]
  l1.sort(reverse=True)   >>>>>[5, 4, 3, 2, 1, 1]
  
  

#startwith()

• 检查字符串是否以指定字符串开头，是则True，否则反之

  name = "aleX leNb sdq"
  print(name.startswith('al')) >>>>Ture
  
  

• 也可指定在范围内查找

  name = "aleX leNb sdq"
  print(name.startswith('l', 1, 4)) >>>>Ture
  print(name.startswith('d', 11, 12)) >>>>Ture
  print(name.startswith('e', 3, 12)) >>>>False
  
  

#endswith()

• 检查字符串是否以指定字符串结尾，是则True，否则反之
• 也可指定在范围内查找，与startswith用法相同

#replace()

• 把字符串中的旧字符串换成新的字符串，也可指定被替换多少次

  name = "aleX"
  print(name.replace("aleX", "chenhao" )) >>>chenhao
  name = " aleX aleX aleX aleX aleX "
  print(name.replace("aleX", "chenhao", 2)) 
  >>>> chenhao chenhao aleX aleX aleX 
  
  

#len()

• 返回字符串、元组、列表等得长度

  s = "asdfer"
  print(len(s))
  >>>>6
  
  

#bin()

• 将十进制转换为二进制

  print(bin(14))  >>>>0b1110
  print(bin(10))  >>>>0b1010
  
  

#int()

• int(字符串，2) 将某个进制转换为十进制

print(int("0b1111011",2))     #将2进制转换成十进制

#oct()

• oct()将一个整数转换成8进制

print(oct(30))  >>>0o36

#hex()

• 将16进制转换成10进制

print(hex(87))   >>>>0x57

#is系列，判断系列

• isalnum() 判断是不是由字母,中文,数字组成,返回的是布尔值

• isalpha() 判断是不是由字母,中文组成,返回的是布尔值

• isdigit() 判断是不是阿拉伯数字 (⑤ 这是一个bug)

• isdecimal() 判断是不是十进制,返回的是布尔值

  name = "1234"
  print(name.isalnum())>>>>Ture
  print(name.isalpha())>>>>False
  print(name.isdigit())>>>>Ture
  print(name.isdecimal()) >>>>Ture
  
  

#keys()、values()

• 返回可迭代对象

    info = {'k1':'v2', 'k2': 'v2'}
    print(info.keys())  >>>>dict_keys(['k1', 'k2'])
    print(info.values()) >>>>dict_values(['v2', 'v2'])
  
  

#items

• 用于字典，返回的是一个列表，以元组的形式获取所有的键和值

  dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
  print(dic.items())
  >>>>dict_items([('k1', 'v1'), ('k2', 'v2'), ('k3', [11, 22, 33])])
  
  

#join

• 将序列中的元素以指定的字符连接生成一个新的字符串（不指定为空）
• 序列中的元素必须是可迭代的

li = ["alex", "wusir", "taibai"]
a = "_".join(li)
print(a)  >>>>alex_wusir_taibai

lst = ["asd","1231","asdasd"]
print("".join(lst))
>>>asd1231asdasd

#id()

• 查看数据的内存地址

a = 10
b = 10
c = 20
print(id(a), id(b), id(c))
>>>>140726332256800 140726332256800 140726332257120

#bit.length()

a = 10000
b = 10
print(a.bit_length(),b.bit_length())
>>>>14 4

#encode()#decode()

• encode() 指定的编码格式编码字符串
• decode() 指定的编码格式解码字符串。默认编码为字符串编码

s = "你好"
s1 = s.encode("utf-8")       # 编码
print(s1)
>>>>b'xe4xbdxa0xe5xa5xbd'
s2 = s1.decode("utf-8")      # 解码
print(s2)
>>>>你好

#enumerate()

将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标

lst = [11,22,33,44]
for i in enumerate(lst):
    print(i)
>>>(0, 11)
   (1, 22)
   (2, 33)
   (3, 44)

#iter()

• 生成一个迭代器

#next()

• 返回迭代器的内容

#import time 标准库

• time.time()

  返回当前的时间戳

• time.sleep(2)

  休眠2秒

2.内置函数

#callable()

• 判断是否可调用

  def func():
      pass
  print(callable(func))
  >>>True
  
  

#chr()

• 根据当前编码，查看编码对应的内容(unicdoe)

  print(chr(20320))  
  >>>你
  
  

#odr()

• 查看内存对应的编码

  print(ord("你")) 
  >>>20320
  
  

#complex

• 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数

  print(complex(20))      >>>(20+0j)
  
  

#divmod

• 获取的是元组(第一个是商，第二个是余数)

  print(divmod(20,2))     >>>(10, 0)
  
  

#frozenset()

• 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

  print(frozenset(range(10)))
  >>>frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
  
  

#eval(禁用)

• 执行字符串类型的代码，并返回最终结果

  eval('2 + 2')  >>>4
  n = 81
  eval('n + 5')  >>>86
  eval('print(666)')  >>>666
  
  
  

#exec(禁用)

• 执行字符串类型的代码

  msg = """                                    # 禁用
  def func():
      print("太厉害了")
  func()
  """
  >>>太厉害了
     None
  
  

#hash()

• 获取一个对象(可哈希对象)的哈希值

  print(hash("st")) >>>1998065027285342699
  print(hash(111))  >>>111
  print(hash(True)) >>>1
  print(hash((1,2)))>>>3713081631934410656
  
  

#help()

• 查看帮助信息

  help(list)
  
  

#进制转换()

print(bin(10))    # 十进制转成二进制
print(oct(10))    # 十进制转成八进制
print(hex(30))    # 十进制转成十六进制
print(int("0x1e",16))
print(int("0o12",8))
print(int("0b1010",2))

#pow()

• 求xy次幂。（三个参数为xy的结果对z取余）

  print(divmod(7,2))  # (3, 1)
  print(round(7/3,2))  # 2.33
  print(round(7/3))  # 2
  print(round(3.32567,3))  # 3.326
  print(pow(2,3))  # 两个参数为2**3次幂
  print(pow(2,3,3))  # 三个参数为2**3次幂，对3取余。
  
  

#repr()

• 原形毕露

  s = "123"
  s1 = 123
  print(repr(s))  >>>'123'  # 原形毕露
  print(s1)  >>>123
  
  

#round()

• 保留小数位，默认是保留整数

  print(round(2.432342324,3)) >>>2.432
  
  

#bytes()

• 用于不同编码之间的转换

  s = '你好'
  bs = s.encode('utf-8')
  print(bs)  >>>b'xe4xbdxa0xe5xa5xbd'
  s1 = bs.decode('utf-8')
  print(s1)  >>>你好
  bs = bytes(s,encoding='utf-8')
  print(bs)  >>>b'xe4xbdxa0xe5xa5xbd'
  b = '你好'.encode('gbk')
  b1 = b.decode('gbk')
  print(b1.encode('utf-8')) >>>b'xe4xbdxa0xe5xa5xbd'
  
  

#all()

• 可迭代对象中，全都是True才是True

#abs()

• 绝对值

  print(abs(-6)) >>>6
  
  

#format()

• 格式转换

  s = "你好"
  s1 =  format(s,">20")
  s2 =  format(s,"<20")
  s3 =  format(s,"^20")
  print(s1)  >>>                  你好
  print(s2)  >>>你好                  
  print(s3)  >>>         你好         
  
  

#sum()

• 算数

  print(sum([1,2,3,4]))  >>>10
  
  

#dir()

• 查看当前对象都有神马方法

#filter()

• 过滤

• 用法

  filter(function, iterable)
  function -- 判断函数。
  iterable -- 可迭代对象。
  
  

  lst = [1,2,3,4,54,65,7,8,]
  print(list(filter(lambda x:x>4,lst)))
  >>>[<function func at 0x00000208ADF863A8>, <function func at 0x00000208ADF861F8>, <function func at 0x00000208ADF86438>]
  [54, 65, 7, 8]
  
  

  lst = [{'id':1,'name':'alex','age':18},
          {'id':1,'name':'wusir','age':17},
          {'id':1,'name':'taibai','age':16},]
  print(list(filter(lambda a:len(a["name"]) < 5,lst)))
  >>>[{'id': 1, 'name': 'alex', 'age': 18}]
  
  

  模拟内置函数filter
  def filter(func,iter):      # filter
      lst = []           # [54,65,7,8]
      for i in iter:
          if func(i):
              lst.append(i)
      return lst
   lst = [1,2,3,4,54,65,7,8,]
  
  

#map()

• 会根据提供的函数对指定序列做映射。

• 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

• map(function, iterable, ...)
  第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
  function -- 函数
  iterable -- 一个或多个序列
  
  

• 映射，会根据提供的函数对指定序列做映射

  lst = [1,2,3,4,5,6,8,9]
  print(list(map(str,lst))) >>>['1', '2', '3', '4', '5', '6', '8', '9']
  
  

  lst1 = [1,2,3]
  lst2 = [3,2,1]
  lst3 = [3,2,1,5]
  print(list(map(lambda x,y,z:x+y+z,lst1,lst2,lst3))) >>>[7, 6, 5]
  
  

• 例子

  l=[{'name':'alex'},{'name':'y'}]
  l_name = map(lambda x:x['name'] + 'sb',l)
  #(lambda x:x['name']+'sb',l)  lambda匿名函数固定格式 x为匿名函数参数 x['name']+'sb'为函数的额返回值 l为可迭代对象(迭代取l)
  print(list(l_name))
  >>>['alexsb', 'ysb']
  
  

#sorted()

• 排序

• 用法

  sorted(iterable, cmp=None, key=None, reverse=False)
  iterable -- 可迭代对象。
  cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
  key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）
  
  

• 从小到大排序

  lst = [1,2,3,4,65,-7]
  print(sorted(lst))  # 新建列表
  >>>[-7, 1, 2, 3, 4, 65]
  lst.sort()
  print(lst)          #原地修改
  >>>[-7, 1, 2, 3, 4, 65]
  
  

  print(sorted("alex,mdsb"))  # 升序
  print(sorted("alex,mdsb",reverse=True)) # 降序
  >>>
  [',', 'a', 'b', 'd', 'e', 'l', 'm', 's', 'x']
  ['x', 's', 'm', 'l', 'e', 'd', 'b', 'a', ',']
  
  

#zip()

• 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回

  lst1 = [1,2,3]
  lst2 = ['a','b','c','d']
  lst3 = (11,12,13,14,15)
  for i in zip(lst1,lst2,lst3):
      print(i)
  >>>
  (1, 'a', 11)
  (2, 'b', 12)
  (3, 'c', 13)
  
  

#reverse()

• 函数用于反向列表中元素

• aList = [123, 'xyz', 'zara', 'abc', 'xyz']
  aList.reverse()
  print(aList)
  >>>['xyz', 'abc', 'zara', 'xyz', 123]
  
  

#reversed()

• 将一个序列翻转, 返回翻转序列的迭代器

  l = reversed('你好')  # l 获取到的是一个生成器
  print(list(l))
  ret = reversed([1, 4, 3, 7, 9])
  print(list(ret))  >>>[9, 7, 3, 4, 1]
  
  

#map()

• 映射map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function计算列表中每个元素的平方,返回新列表

  lst1 = [1, 2, 3, 4, 5]
  lst2 = [2, 4, 6, 8, 10]
  print(list(map(lambda x, y: x+y, lst1, lst2)))
  >>>[3, 6, 9, 12, 15]
  
  
  

#max()、min()

• 求最大值和最小值

  print(min([1,2,3]))  # 返回此序列最小值
  
  ret = min([1,2,-5,],key=abs)  # 按照绝对值的大小，返回此序列最小值
  print(ret)
  # 加key是可以加函数名，min自动会获取传入函数中的参数的每个元素，然后通过你设定的返回值比较大小，返回最小的传入的那个参数。
  print(min(1,2,-5,6,-3,key=lambda x:abs(x)))  # 可以设置很多参数比较大小
  dic = {'a':3,'b':2,'c':1}
  print(min(dic,key=lambda x:dic[x]))
  
  # x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键
  
  

#reduce

• 累计算

  from functools import reduce
  def func(x,y):
      return x + y
  
  # reduce 的使用方式:
  # reduce(函数名,可迭代对象)  # 这两个参数必须都要有,缺一个不行
  
  ret = reduce(func,[3,4,5,6,7])
  print(ret)  # 结果 25
  reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,
  接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始
  临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推
  
  注意:我们放进去的可迭代对象没有更改
  以上这个例子我们使用sum就可以完全的实现了.我现在有[1,2,3,4]想让列表中的数变成1234,就要用到reduce了.
  普通函数版
  from functools import reduce
  
  def func(x,y):
  
      return x * 10 + y
      # 第一次的时候 x是1 y是2  x乘以10就是10,然后加上y也就是2最终结果是12然后临时存储起来了
      # 第二次的时候x是临时存储的值12 x乘以10就是 120 然后加上y也就是3最终结果是123临时存储起来了
      # 第三次的时候x是临时存储的值123 x乘以10就是 1230 然后加上y也就是4最终结果是1234然后返回了
  
  l = reduce(func,[1,2,3,4])
  print(l)
  
  
  匿名函数版
  l = reduce(lambda x,y:x*10+y,[1,2,3,4])
  print(l)
  
  

#isinstance(obj,cls)：

• 检查obj是不是cls的对象（传两个参数，一个是对象，一个是类）

#issubclass(sub,super)：

• 检查sub是不是super的子类（传两个参数，一个是子类，一个是父类）