复盘：python3编程知识：列表list的append函数、类和实例的__dict__属性

复盘：python3编程知识：列表list的append函数、类和实例的__dict__属性、python函数调用

提示：互联网大厂笔试题

---

题目

python3中运行下列程序试试：有啥结果？

if __name__ == '__main__':

    lists = [1, 2, 3]
    lists.append(lists)
    print(lists)

appen就是追加的意思：

[1, 2, 3, [...]]

Python List append()方法
描述
append() 方法用于在列表末尾添加新的对象。

语法
append()方法语法：
list.append(obj)

参数
obj – 添加到列表末尾的对象。
返回值
该方法无返回值，但是会修改原来的列表。

实例
以下实例展示了 append()函数的使用方法：

#!/usr/bin/python

aList = [123, 'xyz', 'zara', 'abc'];
aList.append( 2009 );
print "Updated List : ", aList;

以上实例输出结果如下：

Updated List :  [123, 'xyz', 'zara', 'abc', 2009]

python函数调用

运行下面代码：输出为

def change(val, tmp = []):
    tmp.append(val)
    return tmp

def f5():
    list1 = change(5)
    print(list1)
    list2 = change(15, [])
    print(list2)
    list3 = change('abc')
    print(list3)

if __name__ == '__main__':
    f5()

输出：

[5]
[15]
[5, 'abc']

继续测试：

list1 = change(5)
    print(list1)
    print(change(1))
    list2 = change(15, [])
    print(list2)
    list3 = change('abc')
    print(list3)

绝了

[5]
[5, 1]
[15]
[5, 1, 'abc']

这个change调用一次，好像就开辟了一个tmp变量？？？？

相当于是change生成了一个tmp变量
保存前年的数据，当你真的[]清空tmp时，才会清空

python的语言特性，因为函数的默认参数会在第一次初始化的时候给它开辟空间，
后面再调用的话不会再初始化，这时候第二次调用使用默认参数会直接用上一个初始化好的那个

牛逼了

def log_time(msg,time = dt.datetime.now()):
    sleep(1)
    print("%s:%s"%(time.isoformat(),msg))

def f6():
    log_time("msg 1")
    log_time("msg 2")
    log_time("msg 3")

if __name__ == '__main__':
    f6()

输出：

2022-07-03T23:44:45.419339:msg 1
2022-07-03T23:44:45.419339:msg 2
2022-07-03T23:44:45.419339:msg 3

---

一、审题

运行下方代码，结果是：

class person:
    def __init__(self, id):
       self.id = id

def f2():
    d = person(100)
    d.__dict__['weight'] = 50
    print(d.weight)
    print(len(d.__dict__))
    print(d.__dict__)
    print(d.weight + len(d.__dict__))


if __name__ == '__main__':
    f2()

结果：

50
2
{'id': 100, 'weight': 50}
52

其实：
Python3的 dict属性 ,是一个字典(dict)，它包含了该对象所有的属性。

类的dict属性，存储 静态函数、类函数、普通函数、全局变量以及一些内置的属性。
类的对象的dict属性，存储与该实例相关的实例属性的字典，例如：self.xxx相关的信息。

案例：

def f3():
    class Person():
        sex = None
        age = 1

        def __init__(self, name):
            self.sex = '男'
            self.age = 30
            self.name = name

        def test(self):
            print('a normal func.')

    class Man(Person):
        sex = None
        age = 1

        def __init__(self, name):
            self.sex = '女'
            self.age = 40
            self.name = name

        def test_B(self):
            print('func named test_B')

    person = Person('Tom')
    man = Man('Jerry')
    print(Person.__dict__)  # 类的dict属性
    
    print(person.__dict__)  # 对象的dict属性
    print(person.__dict__['name'])
    
    print(Man.__dict__)  # 类的dict属性
    print(man.__dict__)  # 对象的dict属性

if __name__ == '__main__':
    f3()

结果：

{'__module__': '__main__', 'sex': None, 'age': 1, '__init__': <function f3.<locals>.Person.__init__ at 0x000001E90DB914C8>, 'test': <function f3.<locals>.Person.test at 0x000001E90DB91558>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
{'sex': '男', 'age': 30, 'name': 'Tom'}
Tom
{'__module__': '__main__', 'sex': None, 'age': 1, '__init__': <function f3.<locals>.Man.__init__ at 0x000001E90DB915E8>, 'test_B': <function f3.<locals>.Man.test_B at 0x000001E90DB91678>, '__doc__': None}
{'sex': '女', 'age': 40, 'name': 'Jerry'}

这样的话，本题的答案你就知道是啥了吧？

从上述案例可以看出：
类的dict属性，返回类内部所有属性和⽅法对应的字典。

类的实例对象 dict属性，返回实例 属性和值组成的字典。

当有继承关系时，父类的dict 并不会影响子类的dict
内置的数据类型没有dict属性，例如：

def f4():
    number = 3
    list = []
    dd = {}
    print(list.__dict__)
    print(dd.__dict__)
    print(number.__dict__)

if __name__ == '__main__':
    f4()

报错！！！

    print(list.__dict__)
AttributeError: 'list' object has no attribute '__dict__'

---

总结

提示：重要经验：

1）python3的list有append，就是追加对象
2）python3的dict属性，类的属性，既包括成员变量字典，也包括函数，而实例对象的dict属性，只包含成员变量的字典
3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。