Python的note

1. 排序sorted与sort比较
   Python list内置sort()方法用来排序，也可以用python内置的全局sorted()方法来对可迭代的序列排序生成新的序列。

sorted(iterable,key=None,reverse=False)

# 字典排序，字典是没有顺序的，排序后返回列表
# sorted的结果是一个list
dic1SortList = sorted(dic1.items(),key = lambda x:x[1],reverse = True)

对所有可迭代的对象均有效。
sort只是列表的内置方法，直接操作指针。

2. random.sample()

   # random.sample(list1, 5)#从list1中随机选取5个元素

从指定文件夹中选取一定数量的图片，随机。

##深度学习过程中，需要制作训练集和验证集、测试集的代码段。

import os, random, shutil
def moveFile(fileDir):
        pathDir = os.listdir(fileDir)    #取图片的原始路径
        filenumber=len(pathDir)
        rate=0.1    #自定义抽取图片的比例，比方说100张抽10张，那就是0.1
        picknumber=int(filenumber*rate) #按照rate比例从文件夹中取一定数量图片
        sample = random.sample(pathDir, picknumber)  #随机选取picknumber数量的样本图片
        print(sample)
        for name in sample:
                shutil.move(fileDir+name, tarDir+name)
        return

if __name__ == '__main__':
	fileDir = "./source/"    #源图片文件夹路径
	tarDir = './result/'    #移动到新的文件夹路径
	moveFile(fileDir)

3. 给代码加上进度条，加在for外层

from tqdm import tqdm
import time
for i in tqdm(range(365)):
        time.sleep(0.2)

对for的循环添加进度条，进度条也要脸，^_。

4. 高阶函数用法

foo = [1,2,3]
a = list(map(lambda x:x**2, foo))
print(a)
b = list(filter(lambda x:x%2==0, foo))
print(b)

a = list(filter(lambda x:x%2==0 , list(range(10)) ))
print(a)

b = list(range(-10, 10))
b.sort(key=lambda x: abs(x))
print(b)

5. 推导式如下

print([i for i in range(10) if i %2 ==0])

6. 字典交换key和value

mcase = {'a': 10, 'b': 34}
mcase_frequency = {v: k for k, v in mcase.items()}
print mcase_frequency

5. 生成字典，key正序，value倒序

dict1 = {key:value for key,value in enumerate(reversed(range(10)))}
print(dict1)
#{0: 9, 1: 8, 2: 7, 3: 6, 4: 5, 5: 4, 6: 3, 7: 2, 8: 1, 9: 0}

6. 嵌套列表 推导式（少见）

list1 = [range(10), range(10,20)]
events = [i for lst in list1 for i in lst if i%2==0]
print(events)
#[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

7. 规范字符串，首字母大写

name = ["jim", "tom"]
print(list(map(str.title, name)))

8. return 带过滤规则

num =  range(-10,30)
def neg(str):
    return str < 0
print(list(filter(neg, num)))

9. set 和 frozenset

set无序排序且不重复，是可变的，有add()，remove()等方法。既然是可变的，所以它不存在哈希值.
集合对象还支持union(并集), intersection(交集), difference(差集)和sysmmetric difference(对称差集)等数学运算. 
sets 支持 x in set, len(set),和 for x in set。作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持 indexing, 或其它类序列的操作。
frozenset是冻结的集合，它是不可变的，存在哈希值

此条来自博客，更多…
10. x=x+1和 x+=1比较

 x=x+1效率最低，因为它的执行过程如下：
（1）读取右x的地址。
（2）x+1.做加1操作
（3）读取左x的地址。
（4）将右值传给左边的x（编译器并不认为左右x的地址相同）。
(改变左边的数值)
 x+=1其次，其执行过程如下：
（1）读取右x的地址。
（2）x+1.做加1操作
（3）将得到的值传给x（因为x的地址已经读出）。
 (不改变左边的数值)
  x++效率最高，其执行过程如下：
（1）读取右x的地址。
（2）x自增1。

11. 装饰器复习，装饰器是一个闭包函数，@后面看做一个函数

fucn = deco('pars')(func)

12. assert num int #错误抛出 AssertionError
13. all([‘a’, ‘b’, ‘c’, ‘d’]) # 列表list，元素都不为空或0的时候返回True
14. 一篇很奇葩的PY3用法，
15. 二进制转化为16进制

 rol.append('%x' % int(a, 2))

16. map函数和 functool.reduce函数
    一篇文章写的比我好，搬运
17. 二进制转化为16进制

 num = format(int("".join(a), 2), "x")

18. python优化的[20个建议]
19. 字典value计数+1的方法：

    方法一：
     d[hid].setdefault(ip,0)
     d[hid][ ip ]+=1
     方法二：
     d[hid][ ip ] = d[hid].get(ip, 0) + 1
    

20. for或while后面跟else：当for或while循环不被打断时候会执行else里的语句，打断不执行else。
21. 字符串的编码方式：utf-8, utf-7, GBK(gb2312), Ascii,etc。python的chardet模块可以方便我们检测字符串的编码方式。py的json模块默认是utf-8的编码方式，可以用encoding参数解析其他编码格式。
22. 静态方法和类方法意义：
    静态方法（@staticmethod）：
    不需要实例化，不需要（也不能）从实例对象中调用方法或属性。参数中不要写self或cls。
    类方法（@classmethod）：
    某些方法放在类中实现更符合逻辑（相当于我什么没说），用来传递类的属性或方法，（实例可以调用类方法和属性，类方法不可调用实例方法），比如例子。参数名一般约定为“cls”。
23. MVC设计模式，模型尽量抽到M中，C业务调用为主。
    桥接模式，对象丙不同属性抽象到不同类中，属性中传入类甲和乙，调用甲self.属性.属性。
24. 合并两个链表不同元素，推导式来写：

c = [x for x in list1 if x in list2]
d = [y for y in (list1+list2) if y not in c]

25. 列表去重

b = [x for x in a if a.count(x) == 1]

a = [1, 3]
b = [2, 3, 4]
c = []
[c.append(i) for i in a+b if not i in c] 
print(c)

26. join的性能明显好于+。这是为什么呢？
    字符串是不可变对象，当用操作符+连接字符串的时候，每执行一次+都会申请一块新的内存，因此用+连接字符串的时候会涉及好几次内存申请和复制。而join在连接字符串的时候，会先计算需要多大的内存存放结果，然后一次性申请所需内存并将字符串复制过去，这是为什么join的性能优于+的原因。
27. pip 下载和pip查看可用的版本

pip download -d \home\packs -r requirement.txt  # 下载到/home/packs
pip install pakage==
pip freeze > requirements.txt

28. 当前文件所在路径，用于相对路径的修改。

current_path = os.path.dirname(__file__)

29. 关于python3优化后生成器的使用注意

比如调用dict的.items() 或者.values()方法，返回的数据类型是
<class 'dict_items'> ,<class 'dict_values'>
是迭代器，可以迭代，但是不能切片和索引。

30. 修改默认的python2为anaconda2

重命名软连接  /usr/bin/pyhton2，当做还原的备份了。
sudo ln -s  /home/alex/anaconda2/bin/python /usr/bin/python2

31. 两个字典组合，3个方法

print({**a, **b})
a.update(b)
print(dict(tuple(a.items()) + tuple(b.items())))

33. functools.partial()

这个函数的应用场景如，使用正则化匹配某些字符串单词，
但是字符串单词之间可能有空格，也可能没有空格（只有一个单词），
那么久会用到条件判断，其实可以定义多个函数，在不同条件调用不同函数。
其实每个条件判断里都需要传入不同的匹配模式，为了方便统一调用。所以用partial。
偏函数（Partial function）是通过将一个函数的部分参数预先绑定为某些值，
从而得到一个新的具有较少可变参数的函数

参考自
34. python弱类型

py的弱类型和c语言不同。对于你周围水平比较洼的同事，他可能无视你的接口提示，为了防止他们乱传参，乱喷。
有两种解决方案：
1. 启用py3.7以来的新特性,
findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float: 
2. 如果停留在py2或者老版本的py3用，断言 

35. 时间戳

import time
time_stamp = time.strftime('%Y-%m-%d-%H-%M-%S',time.localtime(time.time()))

36. 搜索多种路径结尾的文件

#1, 可能会有win平台不分大小写问题，另外可能会扫到其他后缀的文件
In [12]: glob.glob(rootpath+ '/*[jpg, gif]')                                             
Out[12]: ['/home/alex/temp/1.jpg', '/home/alex/temp/2.gif']

#2，better
import itertools as it, glob
patterns = ["./test/*.%s"%i for i in ("JPG", "jpg", "jpeg", "JPEG")]
im_iterator = it.chain.from_iterable(glob.iglob(pattern) for pattern in patterns)

37. 操作系统版本和python版本是否为64

if sys.platform == "win32":
if "64 bit" in sys.version or "64" in paltform.architecture()[0]:

38. list[:], list.copy()会生成新id的对象
    除非直接传递list， 否则任何形式的切片都是会改变list的id，ls[:]也不行， 即新创建了列表实例。

39. 字典的几个方法，参考了

# 批量构造键值对
dict.fromkeys(range(5), "aa")
{0: 'aa', 1: 'aa', 2: 'aa', 3: 'aa', 4: 'aa'}

# 用已有的字典初始化新dict
d = dict(one=1, two=2, three=3, four=4, five=5)

dict.fromkeys(d)
{'one': None, 'two': None, 'three': None, 'four': None, 'five': None}

# 用字符串构造字典，可以换list， 和tuple
>>> dict.fromkeys("abcd","aa")
{'a': 'aa', 'b': 'aa', 'c': 'aa', 'd': 'aa'}

>>> L = ["a", "b", "c", "d"]
>>> dict.fromkeys(L)
{'a': None, 'b': None, 'c': None, 'd': None}

# 比较常用，无则添加
d.setdefault("five")

# pop(key,default)用来移除给定的元素并返回移除的元素
 d.pop("one")

# 删除指定元素
del d["one"]

• 嵌套列表的组合

[[1]]+[[2]]
Out[23]: [[1], [2]]
[1]+[2]
Out[24]: [1, 2]