Python入门-内置对象函数

1.callable（）

查看函数知否可调用，可调用返回True，不可用返回False

print("input函数：", callable(input))
#input函数： True

2.eval（）

print(eval("3+3"))
# 6


num = 10
s = "加法计算：{}"
var = dict(num =num, info = s)

res = eval("info.format(num *2)", var)
res   
# '加法计算：20'


l = "[1,2,3]"
t = "(1,2,3)"
d = "{1:'one',2:'two',3:'three'}"
res = eval(l)
res2 = eval(t)
res3 = eval(d)
print(res, res2, res3)
print(type(res,),type(res2), type(res3))
"""
[1, 2, 3] (1, 2, 3) {1: 'one', 2: 'two', 3: 'three'}
<class 'list'> <class 'tuple'> <class 'dict'>
"""

3.exec()

num =10
exec("num += 11")
num  
# 21


s = "for i in range(10):"\
    "print(i,end= ',')"
res = exec(s)
print()
print(res)
"""
0,1,2,3,4,5,6,7,8,9,
None
"""

4.compie（）

s = "11 + 22 "
code = compile(s, " ","eval")
res = eval(code)
res
# 33

s = "data = input('请输入：')"
code = compile(s,"", "single")
exec(code)

print("输入数据为：", data)
"""
请输入： 99
输入数据为： 99
"""

s = []
data = "for i in range(2):s.append(input('请输入：'))"
code = compile(data, "", "exec")
exec(code)
exec("print('经常访问的地址：',s)")
"""
请输入： baidu
请输入： google
经常访问的地址： ['baidu', 'google']
"""

5.map映射

#1.需求：已知[1,2,3,4,5],生成[1,4,9,16,25]
list1 = list(range(1,6))
def func(x):
    return x ** 2
res = map(func,list1)
print(res)
print(list(res))
"""
<map object at 0x0000000005247100>
[1, 4, 9, 16, 25]
"""

#2.两个列表求和
def add(x,y):
    return  x + y
result = map(add,[1,2,3],[4,5,6,7])
print(list(result))
#[5, 7, 9]

#3.字符串转化
list1 = ["faf","Hello","AAA"]
result = list(map(lambda ch:ch.upper(),list1))
print(result)
#['FAF', 'HELLO', 'AAA']

"""
注意：
 1.map中的序列有几个，函数的参数一般设置几个【一一对应】
 2.map中的函数一般都要设置返回值，否则生成的元素全部是None【将函数运算的结果存储在一个新的容器中】
 3.多个序列的长度可以不一致，以元素个数少的序列作为参照
"""

 6.reduce减少【累积】

from functools import  reduce
"""
reduce(fn，Iterable)

功能：使用fn首先将Iterable中第0和第1个元素进行运算，将得到的结果和第2个元素进行运算。。。。
直到Iterable中元素全部参与运算
举例：
func(x,y)
[a,b,c,d]

reduce(func,[a,b,c,d])

工作原理：
func(func(func(a,b),c),d)
"""

#1.需求:求 一个列表中所有的元素和
#方式一：设置函数
def test(x,y):
    return x * y
result21 = reduce(test,range(1,11))
print(result21)

#方式二：匿名函数
result22 = reduce(lambda x,y:x * y,range(1,11))
print(result22)

#需求2：将列表[2,4,6,8]转换为整数2468
def check(x,y):
    return  x * 10 + y
result3 = reduce(check,[2,4,6,8])
print(result3)

result31 = reduce(lambda x,y:x * 10 + y,[2,4,6,8])
print(result31)

 map和reduce联合使用

#需求：使用map和reduce实现字符串转整型的操作，例如："6523" --->6523
#第一步：建立映射关系
def strtoint(s):
    dict1 = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6}
    return dict1[s]

result1 = list(map(strtoint,"6523"))
print(result1)

#第二步：实现转换
result2 = reduce(lambda x,y:x * 10 + y,result1)
print(result2)

#合起来写
result3 = reduce(lambda  x,y:x * 10 + y,map(strtoint,"6532"))
print(result3)

 7.filter过滤

"""
filter(fn,Iterable)

功能：通过一定的条件过滤可迭代对象中数据，
   根据函数的返回值为True或者False决定是否保留元素，如果为True则保留，为False则过滤
"""
#案例演示一：将列表中的偶数元素保留，将奇数元素过滤
list1 = list(range(1,11))
def check(num):
    if num % 2 == 0:
        return True
    else:
        return False

result1 = filter(check,list1)
print(result1)
print(list(result1))
"""
<filter object at 0x0000000005247C70>
[2, 4, 6, 8, 10]
​"""

#案例演示二：将其中为“无”的数据过滤掉
list2 = [["张三",18,100,"跳舞"],["lisi",15,95,"无"],["jack",19,60,"唱歌"]]

def test(ch):
    if ch == "无":
        return False
    return True

newlist = []
for sublist in list2:
    m = filter(test,sublist)
    newlist.append(list(m))
print(newlist)
"""
[['张三', 18, 100, '跳舞'], ['lisi', 15, 95], ['jack', 19, 60, '唱歌']]
"""

 8.sorted排序

#一、sort======================================================
list1 = [3,534,54,654,28]
print(list1)
#1.升序list1.sort()print(list1)

#2.降序
list1.sort(reverse=True)
print(list1)

#3.自定义排序规则
list1 = ["ff","6fhufhua","hello","aba"]
list1.sort(key=len,reverse=True)
print(list1)

#4.自定义排序规则
list1 = ["ff","6fhufhua","hello","aba"]
def func(ch):
    return ch.upper()
list1.sort(key=func)
print(list1)#二、sorted======================================================
list1 = [3,534,54,654,28]
print(list1)
#1.升序
list2 = sorted(list1)
print(list1)
print(list2)

#2.降序
list3 = sorted(list1,reverse=True)
print(list3)

#3.自定义排序规则
list1 = ["ff","6fhufhua","hello","aba"]
list4 = sorted(list1,key=len,reverse=True)
print(list4)

#4.自定义排序规则
list1 = ["ff","6fhufhua","hello","aba"]
def func(ch):
    return ch.upper()

list2 = sorted(list1,key=func)
print(list2)

""""
不同点：
 1.经过排序，sorted相比较于sort，生成了一个新的列表
 2.sort是属于列表的功能，但是，sorted中的数据可以是任意的可迭代对象

相同点：
 1.进行降序排序时，都使用reverse=True
 2.如果要自定义排序的规则，可以自定义函数，二者使用的都是key=函数名
"""

 9.模块copy

从整个对象来看：引用，copy， deepcopy

#不可变对象：何种方式，对象和ID，都始终不变=============================================
import copy
a = "tom"
b=a
c=copy.copy(a)
d = copy.deepcopy(a)
print(a,id(a))
print(b, id(b))
print(c, id(c))
print(d, id(d))
"""
tom 1749747452400 原始数据
tom 1749747452400 引用
tom 1749747452400 浅拷贝
tom 1749747452400 深拷贝
"""
#可变对象：不管是copy，还是deepcopy，ID都会改变，但对象不变==========================
a=[1,2,3]
print(a,id(a))
b=a
c=copy.copy(a)
d=copy.deepcopy(a)
a[0]=111
print(a,id(a))
print(b, id(b))
print(c, id(c))
print(d, id(d))
"""
[1,   2, 3] 1749747485056 修改前数据
[111, 2, 3] 1749747485056 原始数据
[111, 2, 3] 1749747485056 引用
[1, 2, 3] 1749747484224   浅拷贝
[1, 2, 3] 1749747485248   深拷贝
"""

从对象的子对象来看

# 子对象，是可变对象，所以ID始终不变，但是深拷贝数据保持不变，其他方式，数据均等于引用
a=[1,2, [3,4]]
b = a
c=copy.copy(a)
d=copy.deepcopy(a)
print(a[2],id(a[2]))
print(b[2], id(b[2]))
print(c[2], id(c[2]))
print(d[2], id(d[2]))
print("修改后".center(20,"*"))
a[2].append(5)
print(a[2],id(a[2]))
print(b[2], id(b[2]))
print(c[2], id(c[2]))
print(d[2], id(d[2]))
"""
[3, 4]    1749747292992 原始数据
[3, 4]    1749747292992 引用
[3, 4]    1749747292992 浅拷贝
[3, 4]    1749747496192 深拷贝
*************修改后***************
[3, 4, 5] 1749747292992 原始数据
[3, 4, 5] 1749747292992 引用
[3, 4, 5] 1749747292992 浅拷贝
[3, 4]    1749747496192 深拷贝
"""