name = input('请输入你的姓名：') s1 = 'taiBAi'
print(s1.upper()) >>>>>TAIBAI全部小写
s1 = 'taiBAi'
print(s1.lower()) >>>>taibaia = range(9)
print(a)
>>>>>range(0, 9)for i in range(5):
print(i)
>>>>0
1
2
3
4for i in range(1,7,2):
print(i)
>>>>1 3 5
for i in range(2,-2,-1):
print(i)
>>>>2 1 0 -1a = range(0,5)
print(a)
Pyrhon2中返回的结果是： [0,1,2,3,4]
Python3中返回的结果是： (0,5)l1 = ("a", "b", "c")
for i in enumerate(l1):
print(i)
>>>>>(0, 'a')
(1, 'b')
(2, 'c')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你好rname = " aleX leNb "
print(name.strip()) >>>>aleX leNb
name1 = "00000alex0000"
print(name1.strip('0')) >>>>>alexa = "alex:alex123"
print(a.split(":")) >>>>['alex', 'alex123']
print(a.split("l",1)) >>>>['a','lexalex123']
print(a.split(":")[0]) >>>>alex
print(a.split(":")[1]) >>>>alex123b = "dlrblist"
b1 = b.rsplit("l", 1)
print(b1) #['dlrb', 'ist']
b = "dlrblist"
b2 = b.rsplit("l", 2)
print(b2) #['d', 'rb', 'ist']c = "hello\nworld\ndlrb"
c1 = c.splitlines()
print(c1) #['hello', 'world', 'dlrb']首字母大写其余变小写
s1 = 'taiBAi'
print(s1.capitalize())
>>>>Taibai大小写翻转
s1 = 'taiBAi'
print(s1.capitalize())
>>>>TAIbaI每个单词的首字母大写
s1 = 'tai2BAi'
print(s1.capitalize())
>>>>Tai2Bai居中
s1 = 'tai2BAi'
print(s1.center(20))
>>>> tai2BAi
print(s1.center(20,'*'))
>>>>******tai2BAi*******
通过找元素索引，找到第一个就返回，找不到-1
s1 = 'tai2BAi'
print(s1.find('a')) >>> 1
print(s1.find('c')) >>> -1
获取某元素在列表中出现的次数
li = (1, 3, 1, "a", 1, "a", 5, "c")
print(li.count(1)) >>> 3
print(li.count('a')) >>> 2
通过元素的名称获取元素的索引
li = (1, 3, 1, "a", 1, "a", 5, "c")
print(li.index('c')) >>> 7
print(li.index(1)) >>> 0
查看数据类型
a = "坚持"
print(type(a)) >>>> <class 'str'>
a = 4
print(type(a)) >>>> <class 'int'>
用于将整数和字符串转换成浮点数
>>>float(1)
1.0
>>> float(112)
112.0
>>> float(-123.6)
-123.6
>>> float('123') # 字符串
123.0
在源列表对元素进行排序
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]
检查字符串是否以指定字符串开头，是则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
把字符串中的旧字符串换成新的字符串，也可指定被替换多少次
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
返回字符串、元组、列表等得长度
s = "asdfer"
print(len(s))
>>>>6
将十进制转换为二进制
print(bin(14)) >>>>0b1110
print(bin(10)) >>>>0b1010
print(int("0b1111011",2)) #将2进制转换成十进制
print(oct(30)) >>>0o36
print(hex(87)) >>>>0x57
isalnum() 判断是不是由字母,中文,数字组成,返回的是布尔值
isalpha() 判断是不是由字母,中文组成,返回的是布尔值
isdigit() 判断是不是阿拉伯数字 (⑤ 这是一个bug)
isdecimal() 判断是不是十进制,返回的是布尔值
name = "1234"
print(name.isalnum())>>>>Ture
print(name.isalpha())>>>>False
print(name.isdigit())>>>>Ture
print(name.isdecimal()) >>>>Ture
返回可迭代对象
info = {'k1':'v2', 'k2': 'v2'}
print(info.keys()) >>>>dict_keys(['k1', 'k2'])
print(info.values()) >>>>dict_values(['v2', 'v2'])
用于字典，返回的是一个列表，以元组的形式获取所有的键和值
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
print(dic.items())
>>>>dict_items([('k1', 'v1'), ('k2', 'v2'), ('k3', [11, 22, 33])])
li = ["alex", "wusir", "taibai"]
a = "_".join(li)
print(a) >>>>alex_wusir_taibai
lst = ["asd","1231","asdasd"]
print("".join(lst))
>>>asd1231asdasd
a = 10
b = 10
c = 20
print(id(a), id(b), id(c))
>>>>140726332256800 140726332256800 140726332257120
a = 10000
b = 10
print(a.bit_length(),b.bit_length())
>>>>14 4
s = "你好"
s1 = s.encode("utf-8") # 编码
print(s1)
>>>>b'\xe4\xbd\xa0\xe5\xa5\xbd'
s2 = s1.decode("utf-8") # 解码
print(s2)
>>>>你好
将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标
lst = [11,22,33,44]
for i in enumerate(lst):
print(i)
>>>(0, 11)
(1, 22)
(2, 33)
(3, 44)
time.time()
返回当前的时间戳
time.sleep(2)
休眠2秒
判断是否可调用
def func():
pass
print(callable(func))
>>>True
根据当前编码，查看编码对应的内容(unicdoe)
print(chr(20320))
>>>你
查看内存对应的编码
print(ord("你"))
>>>20320
函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数
print(complex(20)) >>>(20+0j)
获取的是元组(第一个是商，第二个是余数)
print(divmod(20,2)) >>>(10, 0)
返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
print(frozenset(range(10)))
>>>frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
执行字符串类型的代码，并返回最终结果
eval('2 + 2') >>>4
n = 81
eval('n + 5') >>>86
eval('print(666)') >>>666
执行字符串类型的代码
msg = """ # 禁用
def func():
print("太厉害了")
func()
"""
>>>太厉害了
None
获取一个对象(可哈希对象)的哈希值
print(hash("st")) >>>1998065027285342699
print(hash(111)) >>>111
print(hash(True)) >>>1
print(hash((1,2)))>>>3713081631934410656
查看帮助信息
help(list)
print(bin(10)) # 十进制转成二进制
print(oct(10)) # 十进制转成八进制
print(hex(30)) # 十进制转成十六进制
print(int("0x1e",16))
print(int("0o12",8))
print(int("0b1010",2))
求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取余。
原形毕露
s = "123"
s1 = 123
print(repr(s)) >>>'123' # 原形毕露
print(s1) >>>123
保留小数位，默认是保留整数
print(round(2.432342324,3)) >>>2.432
用于不同编码之间的转换
s = '你好'
bs = s.encode('utf-8')
print(bs) >>>b'\xe4\xbd\xa0\xe5\xa5\xbd'
s1 = bs.decode('utf-8')
print(s1) >>>你好
bs = bytes(s,encoding='utf-8')
print(bs) >>>b'\xe4\xbd\xa0\xe5\xa5\xbd'
b = '你好'.encode('gbk')
b1 = b.decode('gbk')
print(b1.encode('utf-8')) >>>b'\xe4\xbd\xa0\xe5\xa5\xbd'
绝对值
print(abs(-6)) >>>6
格式转换
s = "你好"
s1 = format(s,">20")
s2 = format(s,"<20")
s3 = format(s,"^20")
print(s1) >>> 你好
print(s2) >>>你好
print(s3) >>> 你好
算数
print(sum([1,2,3,4])) >>>10
查看当前对象都有神马方法
过滤
用法
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,]
会根据提供的函数对指定序列做映射。
第一个参数 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(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', ',']
函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回
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)
函数用于反向列表中元素
aList = [123, 'xyz', 'zara', 'abc', 'xyz']
aList.reverse()
print(aList)
>>>['xyz', 'abc', 'zara', 'xyz', 123]
将一个序列翻转, 返回翻转序列的迭代器
l = reversed('你好') # l 获取到的是一个生成器
print(list(l))
ret = reversed([1, 4, 3, 7, 9])
print(list(ret)) >>>[9, 7, 3, 4, 1]
映射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]
求最大值和最小值
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的值进行比较）返回最小的值对应的键
累计算
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)
原文：https://www.cnblogs.com/Nayears/p/12105924.html