python学习笔记——常用方法记录

保留小数

round方法（数值，保留位数）

any()和all()的用法

#any(x)判断x对象是否为空对象，如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true

#all(x)如果all(x)参数x对象的所有元素不为0、’’、False或者x为空对象，则返回True，否则返回False

源代码

# all()方法源代码
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True


# any()方法源代码
def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

any()方法实例

>>>any(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
True
 
>>> any(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
True
 
>>> any([0, '', False])        # 列表list,元素全为0,'',false
False
 
>>> any(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0
True
 
>>> any(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素
True
 
>>> any((0, '', False))        # 元组tuple，元素全为0,'',false
False
  
>>> any([]) # 空列表
False
 
>>> any(()) # 空元组
False

all()方法实例

>>> all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
>True
>>> all(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
False
>>> all([0, 1，2, 3])          # 列表list，存在一个为0的元素
>False
   
>>> all(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0
>True
>>> all(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素
>False
>>> all((0, 1, 2, 3))          # 元组tuple，存在一个为0的元素
>False
   
>>> all([])             # 空列表
>True
>>> all(())             # 空元组
>True

【注意区分】：
all()方法：空元祖、空列表、空字符返回值为True
any()方法：空元祖、空列表、空字符返回值为False

>>>all([])
>True
>>>any([])
>False
>>>all(())
>True
>>>any(())
>False
>>>all('')
>True
>>>any('')
>False

copy与deepcopy 浅拷贝与深拷贝

1.复制不可变数据类型
不管copy还是deepcopy,都是同一个地址当浅复制的值是不可变对象（数值，字符串，元组）时和=“赋值”的情况一样，对象的id值与浅复制原来的值相同。

import copy

a = '你好'
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))

输出：

你好 2243905567360	
你好 2243905567360
你好 2243905567360
你好 2243905567360

2.复制的值是可变对象（列表和字典）
浅拷贝copy有两种情况：

第一种情况：复制的 对象中无 复杂 子对象，原来值的改变并不会影响浅复制的值，同时浅复制的值改变也并不会影响原来的值。原来值的id值与浅复制原来的值不同。

第二种情况：复制的对象中有 复杂 子对象 （例如列表中的一个子元素是一个列表）， 改变原来的值 中的复杂子对象的值 ，会影响浅复制的值。

深拷贝deepcopy：完全复制独立，包括内层列表和字典。

import copy
# list0 = [1,2,{'name':'9527'}]
list0 = [1,2,[3,4]]
a = copy.copy(list0)
b = copy.deepcopy(list0)
# 外层列表：[1,2,[3,4]]
# 内层列表：[3,4]
# 复杂子对象：[3,4], 我们认为包含嵌套结构的内层列表（字典）为复杂子对象
# 简单子对象：1,2
print('原始数据和原始数据copy、deepcopy后的结果及ID地址')
print('结果表明对于外层列表来说，三者是独立的对象')
print('原始数据和id：',list0,id(list0))
print('原始数据和id：',a,id(a))
print('原始数据和id：',b,id(b))
print('*'*80)
print('测试修改外层列表的简单子对象，也就是修改1或者2')
print('结构表明修改了原始list0之后，a和b并没有随之改变，符合我们的正常逻辑，因为是三个不同的对象')
list0[0] = 0 # 将1改成0
print('将1改成0的结果：',list0)
print('将1改成0的结果：',a)
print('将1改成0的结果：',b)
print('*'*80)
print('测试内层列表的值的修改，也就是测试复杂子对象的值的修改')
print('结果表明copy浅拷贝并没有真正将内层列表（字典）独立拷贝出来，导致修改了list0内层列表（字典）后，a的内层列表（字典）改变')
print('结果表明deepcopy深拷贝可以将内层列表（字典）独立拷贝出来，所以b的内层列表（字典）值不变')
list0[2][0] = 9
print('将3改为9的结果',list0)
print('将3改为9的结果',a)
print('将3改为9的结果',b)

输出结果

原始数据和原始数据copy、deepcopy后的结果及ID地址
结果表明对于外层列表来说，三者是独立的对象
原始数据和id： [1, 2, [3, 4]] 2076092228040	# 原始数据
原始数据和id： [1, 2, [3, 4]] 2076092226568	# copy
原始数据和id： [1, 2, [3, 4]] 2076092246984	# deepcopy
********************************************************************************
测试修改外层列表的简单子对象，也就是修改1或者2
结构表明修改了原始list0之后，a和b并没有随之改变，符合我们的正常逻辑，因为是三个不同的对象
# list0[0] = 0 
将1改成0的结果： [0, 2, [3, 4]]	# 原始数据
将1改成0的结果： [1, 2, [3, 4]]	# copy
将1改成0的结果： [1, 2, [3, 4]]	# deepcopy
********************************************************************************
测试内层列表的值的修改，也就是测试复杂子对象的值的修改
结果表明copy浅拷贝并没有真正将内层列表（字典）独立拷贝出来，导致修改了list0内层列表（字典）后，a的内层列表（字典）改变
结果表明deepcopy深拷贝可以将内层列表（字典）独立拷贝出来，所以b的内层列表（字典）值不变
# list0[2][0] = 9
将3改为9的结果 [0, 2, [9, 4]]		# 原始数据	
将3改为9的结果 [1, 2, [9, 4]]		# copy
将3改为9的结果 [1, 2, [3, 4]]		# deepcopy

sort和sorted

list0 = [1, 10, -2, 5, 8, 0]
list0.sort(reverse=False)
print('list0.sort在list0基础上修改，无返回值',list0)

list1 = [1, 10, -2, 5, 8, 0]
res = sorted(list1,reverse=False)
print('sorted有返回值，是新的list',list1)
print('返回值',res)

输出结果

list0.sort在list0基础上修改，无返回值 [-2, 0, 1, 5, 8, 10]

sorted有返回值，是新的list [1, 10, -2, 5, 8, 0]
返回值 [-2, 0, 1, 5, 8, 10]