python 填小坑

系统 454 0

一 Python 语言中有关复数的概念:

1、虚数不能单独存在,它们总是和一个值为 0.0 的实数部分一起构成一个复数

2、复数由实数部分和虚数部分构成

3、表示虚数的语法:real+imagej

4、实数部分和虚数部分都是浮点数

5、虚数部分必须有后缀j或J

            
              aa=123-12j

print aa.real  # output 实数部分 123.0  
print aa.imag  # output虚数部分 -12.0
print aa.conjugate  # 共轭复数
            
          

 

二 关于 (3, 2) < ('a', 'b')  返回True这件事

首先肯定的是这样写并没有错误,前提是py2运行。 py3 不支持不同类型比较,要这样("3","2") < ("a", "b")。

可是这样比较我还是第一次看到过,一脸懵逼,隐隐约约觉得比的是ascii,一番查找还真是,详情见

https://blog.csdn.net/DeskyAki/article/details/100160599   这篇文章, 博主写得很好

 

三 内置的filter,map,reduce

之前接触过,也会用它,昨天刷笔试题,非得想用lambda装会B,结果遇到了些麻烦, 废了一些时间。

1 map    [1, 2, 3, 4] --> [1,0, 1, 0]

            
              l = [1, 2, 3, 4]
result = map(lambda i: 0 if i % 2 == 0 else 1, l)
print(list(result))
            
          

愚蠢的我企图map(lambda i: 0 for v in l if v % 2 == 0 else 1, l), 显然是不对的,map传的第二个参数是可迭代的,它自动帮你迭代。

而且别忘了list()一下,不这样打印的是map对象。

2 filter  [1, 2, 3, 4] --> [2,4]

            
              l = [1, 2, 3, 4]
result = filter(lambda i:i if i % 2 == 0 else None, l)
print(list(result))

            
          

这里的lambda, 必须写else,,,

 3 reduce 1到100的阶乘

            
              from functools import reduce

result = reduce(lambda a, b: a * b, range(1, 101))
            
          

要引入from functools import reduce

下面是利用递归

            
              def fun(n):
    if n == 1:
        return 1
    return n * fun(n-1)


c = fun(100)
            
          

 

四  s = (1, 2, 3)    del s[2]   会怎样?

会报错啊, 小兄弟。首先集合支持切片操作,是可以拿到值的。

但是,元组值不可修改, 这也包括删除操作, 不能删除更新元组的某一个值,del s  会删除整个集合。元组连像集合的clear()都没有,不能清空,只能删除。更新, 所谓的更新也只是再申请一个内存地址,大概这样子 ll =( s[1] ,s[0], 66 ), 元组允许重复值,可以比较大小。

但设置了s = (1, 1),在设置s = (2, 3), 打印s,s = (2, 3), 也能实现更新, 不过两个s的id不同,本质不是一个s。

 

五 关于元组和集合

为什么发这么大标题,因为在看似很简单的字典和集合中,发现了从未注意的东西。

集合和字典的键必须是可哈希的,集合里面不能装列表,字典的键可以是元组,但是可变元组不可以(元组套列表)

Python支持 深度哈希 ,这就是 我们可以使用元组作为字典键的原因 ,也是我们可以在集合中使用元组的原因。

            
              >>> a = {['1', '2']}
Traceback (most recent call last):
  File "
              
                ", line 1, in 
                
                  
TypeError: unhashable type: 'list'
                
              
            
          

详见参考 https://blog.csdn.net/DeskyAki/article/details/100160599

 

六 关于*args, **kwargs 

说实话,现在在找工作,还搞这个有些恥ずかしい、但是真有一些细节值得我去深析

            
              def a(*args, **kwargs):
    print(args, type(args))
    print(*args)
    print("xx"*66)
    print(kwargs, type(kwargs))
    print(*kwargs)
    # print(**kwargs)
    # 报错 'c' is an invalid keyword argument for print()


a(m1, m2, c=[1, 2, 3])

([[1, -2, 1], [-3, 4, 1], [1, 1, 1]], [[2, -1, 1], [0, -1, 1], [1, 1, 1]]) 
              
                
[[1, -2, 1], [-3, 4, 1], [1, 1, 1]] [[2, -1, 1], [0, -1, 1], [1, 1, 1]]
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
{'c': [1, 2, 3]} 
                
                  
c
                
              
            
          

之前我没想过打印args, *args, kwagrs, *kwagrs, **kwargs, 拿到什么类型的数据, 只是知道这样可以拿到所有的位置和关键字参数,*可以把参数们打乱。

  • 打印args, 拿到被元组包裹的所有的位置参数, 元组类型
  • 打印*args, 拿到所有的位置参数
  • 打印kwargs, 字典类型,关键字参数被打成了字典
  • 打印*kwargs, 拿到的却是关键字参数的键(叫键应该对吧)
  • 而 打印**kwargs, 报错,, mmm

几个小例子

            
              a = [([1, -2, 1], [2, -1, 1])]
print(*a)

# ([1, -2, 1], [2, -1, 1])
* 只能打开一层
            
          
            
              a = ([1, -2, 1], [2, -1, 1])
print(*a)
c = zip(*a)
print(list(c))


# [1, -2, 1] [2, -1, 1]
# [(1, 2), (-2, -1), (1, 1)]
虽然打印, 是没逗号的, 但是zip可以直接用*a
            
          

 小例子

            
              li = [lambda:x for x in range(10)]
print(li)           # [
              
                
                  .
                  
                     at 0x0000018062D97268>, ,,,,,,
print(type(li))     # list
print(type(li[0]))  # function
res = li[0]()
print(res)          # 9
                  
                
              
            
          

下面序号是任意排的

1  关于类的多态,我原本以为类的多态,是完全分开的,即使面对列表这种可变类型,看来我想多了,类的多态的列表也是一个吊样。

            
              class P(object):
    n = []
    t = "test"


p1 = P()
p2 = P()
print(p1.t)  # test
print(p2.t)  # test
p1.t = "p1"
print(p1.t)  # p1
print(p2.t)  # test
p1.n.append(1)
p2.n.append(2)
print(p1.n)   # [1, 2]
print(p2.n)   # [1, 2]

            
          

2 反转单词和完全不定个数空格组成的字符串,要求单词中的字母顺序不变。

            
              import re

string = "I like  可愛い     もの "
revwords = ''.join(re.split(r"(\s+)", string)[::-1])
print(revwords)

            
          

3 关于类的继承并设置属性

            
              class Parent(object):
    x = 1

class Child1(Parent):
    pass

class Child2(Parent):
    pass


Child1.x = 2
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)
# 3 2 3

            
          

七 关于字典的遍历和修改键

1 遍历字典,增加或删除键值对时,会报错

            
              untimeError: dictionary changed size during iteration  字典在遍历时改变了长度,

            
          

下面两种都会报错。。。。

            
              a = {'a': 1, 'b': 0, 'c': 1, 'd': 0}
for key in a.keys():
    if key == 'b':
        del a[key]
print(a)
            
          
            
              a = {'a': 1, 'b': 0, 'c': 1, 'd': 0}
for key in a.keys():
    if key == 'b':
        a.update({"55": 55})
print(a)
            
          

解决: 遍历时加个list

            
              a = {'a': 1, 'b': 0, 'c': 1, 'd': 0}
for key in list(a.keys()):
    if key == 'b':
        a.update({"55": 55})
print(a)
            
          

2 当遍历字典时, 修改值不会报错

            
              a = {'a': 1, 'b': 0, 'c': 1, 'd': 0}
for key in list(a.keys()):
    if key == 'b':
        a[key] = 66
print(a)
            
          

3 字典不能直接修改键

可以这样

            
              a = {"1": 2}
a.update({'c': a.pop("1")})
print(a)
            
          

 

八 关于遍历列表不能修改值的问题

如下, 直接遍历数组, 直接在遍历值上做操作,可以该值,但是无法返回到数组,所以数组是不会变的。

可以用第二种方法, 更改数组的值, 想想真是瑟瑟发抖, 想当然的可以直接修改值,要是笔试面试出现这种基础问题,估计直接凉凉了吧, 阔怕。

列表生成式, 倒是可以直接修改,因为相当于重写了原来的列表, 实测前后的arr3 id是相同的。

            
              arr = [4, 2, 0, 2, 6, 3, 1]
arr1 = [4, 2, 0, 2, 6, 3, 1]
arr3 = [4, 2, 0, 2, 6, 3, 1]
for i in arr:
    i += 1
print(arr)

# [4, 2, 1, 2, 6, 3, 1]
for i in range(len(arr1)):
    arr1[i] += 1
print(arr1)
# [5, 3, 2, 3, 7, 4, 2]


q = lambda x: [i+1 for i in x]
print(q(arr3))
# [5, 3, 1, 3, 7, 4, 2]
            
          

 

九 关于迭代器和生成器

 一直没太弄清的概念, 因为觉得会for 循环就好了。为了应对面试,大概看了看,结果都没考, GG。

迭代器有next, iter          生成器 使用yield

 

迭代器

for 循环 其实就是先iter(), 在next()。如果没了元素, next()就会抛出   StopIteration异常

            
              l1 = [1, 2, 3]
it = iter(l1)
print(next(it))   # 1
print(next(it))   # 2
            
          

生成器 

创建迭代器的工具,返回数据要用yield

 

 

 

 

 

 

 

 

 


更多文章、技术交流、商务合作、联系博主

微信扫码或搜索:z360901061

微信扫一扫加我为好友

QQ号联系: 360901061

您的支持是博主写作最大的动力,如果您喜欢我的文章,感觉我的文章对您有帮助,请请扫描上面二维码支持博主1元、2元、5元等您想捐的金额吧,狠狠点击下面给点支持吧

发表我的评论
最新评论 总共0条评论