Exercise

"""
问:执行完下面的代码后,  l,m的内容分别是什么?
"""

def func(m):
    for k,v in m.items():
        m[k+2] = v+2

m = {1: 2, 3: 4}
l = m  # 浅拷贝
l[9] = 10
# func(l)
m[7] = 8

print("l:", l)
print("m:", m)

# 解析
# 1. 在Python中遍历字典的时候不能对字典本身做涉及键(key)的操作
# 2. 深浅拷贝的理解

# 打印结果
# l: {1: 2, 3: 4, 9: 10, 7: 8}
# m: {1: 2, 3: 4, 9: 10, 7: 8}

试题1

"""
1. 问: 字符串格式化:%和format 有什么区别?

Python新版本推荐使用format.
Python2.6 新加入的format语法支持.
3.6加入了一个 f-strings新特性
%和format的区别
http://www.cnblogs.com/liwenzhou/p/8570701.html
"""
# 当%格式化元组或者列表时很不方便，而用format就不用考虑是元组或者列表，如下
c = (250, 250)

command1 = "二营长,向他开炮: 敌人坐标:%s" % (c, )
print(command1)  #二营长,向他开炮: 敌人坐标:(250, 250)

command2 = "二营长,向他开炮: 敌人坐标:{}".format(c)
print(command2)  #二营长,向他开炮: 敌人坐标:(250, 250)

# 3.6加入了一个 f-strings新特性，用着更方便
print(f"二营长,向他开炮: 敌人坐标:{c}")   #二营长,向他开炮: 敌人坐标:(250, 250)

# 常用form用法----通过对象属性
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return "{self.name} is {self.age} years old.".format(self=self)

p1 = Person("Alex", 9000)
print(p1)    #Alex is 9000 years old.

data = [11, 22]
print("{0} --- {0}".format(data))         #[11, 22] --- [11, 22]   默认替换元组
print("{0[0]} --- {0[0]}".format(data))   #11 --- 11
print("{0[0]} --- {0[1]}".format(data))   #11 --- 22

print("{:>10}".format(18))        #        18      生成一个十位的数字，右对齐
print("{:0>10}".format(18))       #0000000018      生成一个十位的数字，右对齐，不够的位用0填充
print("{:A>10}".format(18))       #AAAAAAAA18      生成一个十位的数字，右对齐，不够的位用A填充

print("".zfill(10))             #0000000018      把一个字符串转化成一个10位的字符串，左边用0填充

print("{:.4f}".format(3.1415926)) #3.1416          把3.1415926转化成一个带四位小数的浮点数

print("{:,}".format(1234567890))  #1,234,567,890   把1,234,567,890转换成千分位格式的数字

字符串格式化使form与%的区别

详情点击我

# 试题1
# 列表为可变对象，可变对象不能做关键字参数
# func运行时，会为li自动开辟一个内存空间
def foo(arg, li=[]):
    li.append(arg)
    return li

list1 = foo(21)
list2 = foo(21, [1,])
list3 = foo(28)

print(list1)    #[21, 28]
print(list2)    #[1, 21]
print(list3)    #[21, 28]

# 试题2
# li.append()没有返回值
def foo(arg, li=[]):
    return li.append(arg)

list1 = foo(21)
list2 = foo(21, [1,])
list3 = foo(28)

print(list1)   #None
print(list2)   #None
print(list3)   #None

# 试题3
list5 = [11, 22, 33, 44, 55]
print(list5[10:])   #[]

# 打乱列表的顺序
import random
random.shuffle(list5)
print(list5)    #[22, 11, 33, 44, 55]

可变对象不能做关键字参数、append没有返回值

list1 = [11, [22, 3], [4, ], [55, 66], 8, [9, [7, [12, [34, [26]]]]]]
# 去除多余嵌套的列表,得到[11, 22, 3, 4, 55, 66, 8]

# 小剥皮
# [11, [22, 3]]
# [11, [22, [3, 4]]
def func(x):
    return [a for b in x for a in func(b)] if isinstance(x, list) else [x]

def f(x):
    ret = []
    for b in x:
        if isinstance(b, list):
            for a in f(b):
                ret.append(a)
        else:
            ret.append(b)
    return ret

list2 = [11, 22, [33, 44], [55, [66, 77]], [88, [99, [100, [200, [300]]]]]]
ret = f(list2)
print(ret)           #[11, 22, 33, 44, 55, 66, 77, 88, 99, 100, 200, 300]
ret2 = func(list2)
print(ret2)          #[11, 22, 33, 44, 55, 66, 77, 88, 99, 100, 200, 300]

# def f(x):
#     ret = []
#     for b in x:
#         if isinstance(b, list):
#             for a in b:
#                 if isinstance(a,list):
#                     for c in a;
#                 ret.append(a)
#         else:
#             ret.append(b)
#     return ret

递归剥皮嵌套的多层列表