python常用小算法,小语法

python常用小算法，小语法，小知识

简写

res = a if a > b else b

list = [i for i in range(10)]

注: 无法判断else逻辑

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

dict = {k: items[k] for k in items if k not in user_items}

两层for循环

y_list = ['assss','dvv']
[print(i) for y in y_list for i in y]

匿名函数

lambda 参数: 表达式(返回值)
t = lambda x: x+3
print(t(3))

字典排序

dict = {'a': 2, 'e': 3, 'f': 8, 'd': 4}
print(list(sorted(dict.items(), key=lambda x: x[1], reverse=False)))
list = [2, 9, 4, 7]
print(sorted(list))

numpy存储字典

a = {"a": 5, "s": 1}
numpy.save("a.npy", a)
b = numpy.load("a.npy", allow_pickle=True)
# 此时b的type是ndarray
b = b.item()
# 此时的b的type是dict

函数简写

f = lambda x:x**2
print(f(2))

tf.unstack&tf.stack

https://www.jianshu.com/p/25706575f8d4

collections.Counter 计数

https://blog.csdn.net/qq_29678299/article/details/89975667

import collections
import random


# Counter()本身也是个字典类, 也有字典的一些方法

# 计数
# cnt = collections.Counter()
# for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:
#     cnt[word] += 1
#
# # Counter({'blue': 3, 'red': 2, 'green': 1})
# print(cnt)

# elements(): 返回一个迭代器, 其中的元素重复次数和它的count一样多, 如果count<1将被忽略
c = collections.Counter(a=4, b=2, c=0, d=-2, e=3)
print(c)
print(c.elements())
t = list(c.elements())
print(t)
random.shuffle(t)
print(t)

# most_common(): 返回出现频率最多的前3个
print(collections.Counter('abracadabra').most_common(3))

# subtract(): 扣除
c = collections.Counter(a=4, b=2, c=0, d=-2)
d = collections.Counter(a=1, b=2, c=3, d=4)
c.subtract(d)
print(c)

正负无穷float(‘inf’)的一些用法

float("inf"), float("-inf")

python历史简介

https://www.cnblogs.com/vamei/archive/2013/02/06/2892628.html

python小常识

关于GIL全局解释器锁

• GIL 是python的全局解释器锁，同一进程中假如有多个线程运行，一个线程在运行python程序的时候会霸占python解释器（加了一把锁即GIL），使该进程内的其他线程无法运行，等该线程运行完后其他线程才能运行。

• 如果线程运行过程中遇到耗时操作，则解释器锁解开，使其他线程运行。

• 所以在多线程中，线程的运行仍是有先后顺序的，并不是同时进行。

• 多进程中因为每个进程都能被系统分配资源，相当于每个进程有了一个python解释器，所以多进程可以实现多个进程的同时运行，缺点是进程系统资源开销大。

**关于fun(*args, kwargs)
看例子

def f(*args, **kwargs):
    print(args)

    print(kwargs)

f("a", 1, ["a", "q"], dict({"as": 1, "a": 2}), a=1, b=2, c=[0, 1], d={"1": 1})

运行效果
('a', 1, ['a', 'q'], {'as': 1, 'a': 2})
{'a': 1, 'b': 2, 'c': [0, 1], 'd': {'1': 1}}

Python 中的__new__和__init__的区别

• __new__是在实例创建之前被调用的，因为它的任务就是创建实例然后返回该实例对象，是个静态方法。
• __init__是当实例对象创建完成后被调用的，然后设置对象属性的一些初始值，通常用在初始化一个类实例的时候。是一个实例方法。
  也就是： __new__先被调用，__init__后被调用，__new__的返回值（实例）将传递给__init__方法的第一个参数(self)，然后__init__给这个实例设置一些参数。

简述with方法打开处理文件帮我我们做了什么？

f = open("file_path", "w")
try:
	f.write(line)
except:
	pass
finally:
	f.close()

原始字符串

print(r"\n") # 打印为:\n, 而不是换行

正则表达式
…

断言

assert os.path.exists(file_path), "cannot find {}".format(file_path)

字典排序

# 字典排序
d = {"a": 2, "c": 1, "b": 3}
# 按照key排序
l = sorted(d.items(), key=lambda i:i[0], reverse=False)
print(l)

# 按照value排序
l = sorted(d.items(), key=lambda i:i[1], reverse=False)
print(l)

# [('a', 2), ('b', 3), ('c', 1)]
# [('c', 1), ('a', 2), ('b', 3)]

collections.Counter统计

from collections import Counter
s = "adgyhgasjhdghgafdghafdhag]asdjlk;;;:;a"
res = Counter(s)
print(dict(res))
# {'a': 7, 'd': 5, 'g': 6, 'y': 1, 'h': 5, 's': 2, 'j': 2, 'f': 2, ']': 1, 'l': 1, 'k': 1, ';': 4, ':': 1, '/': 4}

使用filter方法过滤

seq = [-1, -2, 3, 5, -1, -3]
res = filter(lambda x:x<0, seq)
print([i for i in res])
# [-1, -2, -1, -3]

时间戳和日期格式相互转换

import time
print("时间戳:", time.time())
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time())))
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(1381419600)))
# 时间戳: 1615465862.4757388
# 2021-03-11 20:31:02
# 2013-10-10 23:40:00

自定义异常

# 自定义异常
try:
    for i in range(5):
        if i > 2:
            raise Exception("数字大于2")
except Exception as e:
    print(e)

字符串拼接join

x = "::"
print(x.join("abc"))
print(x.join(["a", "b", "c"]))
# a::b::c
# a::b::c

try except else finally使用

try:
    f = open("回溯.py", "r")
except Exception as e:
    print(e)
else:
    print("无异常")
finally:
    f.close()

字符串转二进制

# 英文字符串
print(type(b"ads"))
# 中文字符串
print(type("阿达".encode()))

# <class 'bytes'>
# <class 'bytes'>

python实现单例模式

# 单例模式
class Singleton(object):
    __instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

a = Singleton()
b = Singleton()

print(id(a))
print(id(b))
# 1458369503872
# 1458369503872

保留x位小数

import random

a = random.random()
print(a)
print(round(a, 2))

# 0.5677502095964958
# 0.57

可变数据类型和不可变数据类型–理解和举例
不可变数据类型:数值型, 字符串型, 元组
可变数据类型:列表, 字典

# 不可变数据类型: 数值型, 字符串, 元组
a = 3
b = 3
print(id(a), id(b))
s1 = "hello"
s2 = "hello"
print(id(s1), id(s2))
# 140704078899040 140704078899040
# 2104407974320 2104407974320

# 可变数据类型: 列表, 字典
def f(key, value, dic=dict()):
    dic[key] = value
    print(dic)
f("a", 1)
f("b", 2)
f("c", 3, {})
# 字典是可变数据类型, 前两个函数调用该dic指向的是同一地址
# {'a': 1}
# {'a': 1, 'b': 2}
# {'c': 3}

x = [1, 2]
y = [1, 2]
z = x
print(id(x), id(y), id(z))
z.pop()
print(x, z)
# x, z id一致, 操作z, 相当于操作了x
# 2276582249856 2276581513472 2276582249856
# [1] [1]

https://www.cnblogs.com/finer/p/12846475.html 60题

python 元组(tuple)和列表（list）区别

• 相对于 list 而言，tuple 是不可变的，这使得它可以作为 dict 的 key，或者扔进 set 里，而 list 则不行。
• tuple 放弃了对元素的增删（内存结构设计上变的更精简），换取的是性能上的提升：创建 tuple 比 list 要快，存储空间比 list 占用更小。
• 多线程并发的时候，tuple 是不需要加锁的，不用担心安全问题，编写也简单多了。

python深浅复制

• 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。

a = {1: [1,2,3]}
# 浅复制
b = a.copy()
print(a, b)
# {1: [1, 2, 3]}, {1: [1, 2, 3]}

a[1].append(4)
print(a, b)
# {1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]}
# 修改a，b也会被修改，在通常情况下可能造成bug

• 深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。

a = {1: [1,2,3]}
# 深复制
import copy
c = copy.deepcopy(a)
print(a, c)
# {1: [1, 2, 3]}, {1: [1, 2, 3]}

a[1].append(4)
print(a, c)
# {1: [1, 2, 3, 4]}, {1: [1, 2, 3]}
# 修改a，c不会被修改