• 集合set，无序的不重复元素序列

• 字典dict

• 列表list

• 元组tuple，元素不能修改

• 字符串string

• 数字number

• 进制转化

# 十进制转十六进制
print(hex(21))  # 0x15
# 十进制转八进制
print(oct(21))  # 0o25
# 十进制转二进制
print(bin(21))  # 0b10101
# 去除二进制0b
print(bin(21)[2:])  # 10101
# 左侧填充零，补齐位数
print(bin(21)[2:].zfill(2*4))  # 00010101

# 十六进制转十进制
print(int('0x15',16))  # 21
# 八进制转十进制
print(int('0o25',8))  # 21
# 二进制转十进制
print(int('0b10101',2))  # 21

• 多维数组转为一维数组

multi_array = [[1,2,3],[4,5],[6],[7,8,9]]
linear_array = [i for item in multi_array for i in item]

print(linear_array)   # [1, 2, 3, 4, 5, 6, 7, 8, 9]

• 同时获取商和余数

print(divmod(10,3)) # (3, 1)

quotient,remainder = divmod(10,3)
print(quotient,remainder)   # 3 1

• 开N次方

x=64
n=6
print(x**(1/n))   # 2.0

• N次方

x=2
n=6
print(x**n)   # 64

• 0~N 求和

# 递归实现
def func(n):
    if n == 0:
        return 0
    else:
        return n + func(n - 1)


print(func(4))  # 10


# 简化公式计算
def func_b(n):
    return n * (n + 1) / 2


print(func_b(4))  # 10.0

• 0~N求积

# 递归实现
def func(n):
    if n == 1:
        return 1
    else:
        return n * func(n - 1)


print(func(4))  # 24

• 斐波那契数列

def fab_a(n):
    """生成器函数实现"""
    a, b, count = 0, 1, 0
    while count < n:
        yield a
        a, b = b, a + b
        count += 1


def fab_b(n):
    """递归函数实现"""
    if n <= 1:
        return n
    else:
        return fab_b(n - 1) + fab_b(n - 2)


f = fab_a(10)
while True:
    try:
        print(next(f), end=' ')     # 0 1 1 2 3 5 8 13 21 34
    except StopIteration:
        break
print()
for i in range(10):
    print(fab_b(i), end=' ')    # 0 1 1 2 3 5 8 13 21 34
    

• 插入排序

def insert_sort(lst: list) -> list:
    """插入排序
    1. 从第2位开始为未排序序列
    2. 未排序序列中从前往后依次取出1个数与已排序序列从后往前依次比较
    3. 有序序列循环比较过程中大于等于取出值需往后移1位
    4. 最后插入取出值到有序序列
    """
    for i in range(1, len(lst)):
        j = i - 1
        tmp = lst[i]
        while tmp < lst[j] and j >= 0:
            lst[j + 1] = lst[j]
            j -= 1
        lst[j + 1] = tmp


init_list = [8, 6, 9, 10, 2, 16, 0, 3, 7, 4, 2]
insert_sort(init_list)
print(init_list)  # [0, 2, 2, 3, 4, 6, 7, 8, 9, 10, 16]

• 冒泡排序

• def bubble_sort(lst: list) -> None:
      i = 1
      while i < len(lst):   # 轮询次数
          for j in range(len(lst) - i): # 每轮比较次数
              if lst[j] > lst[j + 1]:
                  lst[j], lst[j + 1] = lst[j + 1], lst[j]
          i += 1
          
  # 改进
  def bubble_sort(lst: list) -> None:
      i = 1
      exchanged = True  # 是否发生交换
      while i < len(lst) and exchanged:
          exchanged = False
          for j in range(len(lst) - i):
              if lst[j] > lst[j + 1]:
                  lst[j], lst[j + 1] = lst[j + 1], lst[j]
                  exchanged = True
          i += 1
  

• 选择排序

def selection_sort(lst:list)->None:
    """每轮查询未排序序列的最小值，排到已排序序列末尾
    1. 每轮设置未排序序列第1个为基准值
    2. 从前往后查，记录最小值的索引
    3. 遍历一轮后，交换未排序第1个和最小索引位置的值
    """
    for i in range(len(lst)):
        min_index = i
        for j in range(i+1,len(lst)):
            if lst[min_index] > lst[j]:
                min_index = j
        lst[i],lst[min_index] = lst[min_index],lst[i]

• isdigit、isdecimal、isnumeric的区别

    dec = '10'
    b = b'11'
    chi = '六'
    arab = 'IV'

    print(dec.isdigit())  # true
    print(dec.isnumeric())  # true
    print(dec.isdecimal())  # true

    print(b.isdigit())  # true
    print(b.isnumeric())  # AttributeError: 'bytes' object has no attribute 'isdecimal'
    print(b.isdecimal())  # AttributeError: 'bytes' object has no attribute 'isdecimal'

    print(chi.isdigit())  # False
    print(chi.isnumeric())  # True
    print(chi.isdecimal())  # False

    print(arab.isdigit())  # False
    print(arab.isnumeric())  # False
    print(arab.isdecimal())  # False

• 判断一个字符是否包含大小写字母、数字、符号

import string

a = '字符串'
count = 0
for item in string.ascii_lowercase: # 小写字母
        if item in a:
            count += 1
            break
for item in string.ascii_uppercase: # 大写字母
    if item in a:
        count+=1
        break
for item in string.digits:  # 数字
    if item in a:
        count+=1
        break
for item in string.punctuation: # 符号
    if item in a:
        count+=1
        break

• pytest使用

import pytest


# 固件
@pytest.fixture(autouse=True)
def fix():
    print('This is a fixture function!')
    yield
    print('end')


class TestClass:
    def test_class_one(self):
        assert 1 == 1

    def test_class_two(self):
        assert 1 in [1, 2, 3]


def test_one():
    assert 1 == 1


# 跳过
@pytest.mark.skip(reason='跳过测试')
def test_two():
    assert 'a' in 'bac'


# 条件跳过
@pytest.mark.skipif(pytest.__version__ < '8', reason='版本小于7')
def test_three():
    assert 4 > 5


@pytest.mark.run(order=2)  # 第2个执行
@pytest.mark.xfail(pytest.__version__ < '8', reason='不支持的版本')
def test_four():
    assert 2 == 2


# 设置执行顺序，需安装pytest-ordering
@pytest.mark.parametrize(('var', 'pwd'), [(1, 9), (2, 4), (3, 9)])
@pytest.mark.run(order=1)  # 第1个执行
def test_five(var, pwd):
    assert var + pwd < 11


# 失败重试 ，需安装pytest-rerunfailures
# 方式一：命令行失败重试  pytest -v --reruns 2 --reruns-delay 5 test_rerun.py
# 方式二：脚本中失败重试
@pytest.mark.flaky(reruns=2, reruns_delay=3)  # 重试两次，每次延时3秒执行
def test_six():
    assert 'a' in ['b', 'c']

• 格式说明符号

写在表达式后面，可以更好地控制格式化值的方式

# 将 pi 舍入到小数点后三位
import math
print(f'The value of pi is approximately {math.pi:.3f}.')   # The value of pi is approximately 3.142.

# 在 ':' 后传递整数，为该字段设置最小字符宽度，常用于列对齐
table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
for name, phone in table.items():
    print(f'{name:10} ==> {phone:10d}')
# Sjoerd     ==>       4127
# Jack       ==>       4098
# Dcab       ==>       7678

# 可以在格式化前转换值。 '!a' 应用 ascii() ，'!s' 应用 str()，'!r' 应用 repr()
animals = 'eels'
print(f'My hovercraft is full of {animals}.')   # My hovercraft is full of eels.
print(f'My hovercraft is full of {animals!r}.')   # My hovercraft is full of 'eels'.

# = 说明符可被用于将一个表达式扩展为表达式文本、等号再加表达式求值结果的形式。【此特性是3.12新增，老版本不支持】
bugs = 'roaches'
count = 13
area = 'living room'
print(f'Debugging {bugs=} {count=} {area=}')     # Debugging bugs='roaches' count=13 area='living room'

• 作用域和命名空间

# global 语句用于表明特定变量在全局作用域里，并应在全局作用域中重新绑定；nonlocal 语句表明特定变量在外层作用域中，并应在外层作用域中重新绑定。
# 下例演示了如何引用不同作用域和名称空间，以及 global 和 nonlocal 对变量绑定的影响：
def scope_test():
    def do_local():
        spam = "local spam"

    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"

    def do_global():
        global spam
        spam = "global spam"

    spam = "test spam"
    do_local()
    print("After local assignment:", spam)  # After local assignment: test spam
    do_nonlocal()
    print("After nonlocal assignment:", spam)   # After nonlocal assignment: nonlocal spam
    do_global()
    print("After global assignment:", spam)   # After global assignment: nonlocal spam

scope_test()
print("In global scope:", spam)   # In global scope: global spam

• 类和实例变量

实例变量用于每个实例的唯一数据，而类变量用于类的所有实例共享的属性和方法

class Dog:

    kind = 'canine'         # class variable shared by all instances

    def __init__(self, name):
        self.name = name    # instance variable unique to each instance

d = Dog('Fido')
e = Dog('Buddy')
print(d.kind)   # 'canine'               # shared by all dogs
print(e.kind)    # 'canine'              # shared by all dogs
print(d.name)   # 'Fido'               # unique to d
print(e.name)    # 'Buddy'              # unique to e



# 例如以下代码中的 tricks 列表不应该被用作类变量，因为所有的 Dog 实例将只共享一个单独的列表:
class Dog:

    tricks = []             # mistaken use of a class variable

    def __init__(self, name):
        self.name = name

    def add_trick(self, trick):
        self.tricks.append(trick)

d = Dog('Fido')
e = Dog('Buddy')
d.add_trick('roll over')
e.add_trick('play dead')
print(d.tricks)  #['roll over', 'play dead']         # unexpectedly shared by all dogs



# 正确的类设计应该使用实例变量:
class Dog:

    def __init__(self, name):
        self.name = name
        self.tricks = []    # creates a new empty list for each dog

    def add_trick(self, trick):
        self.tricks.append(trick)

d = Dog('Fido')
e = Dog('Buddy')
d.add_trick('roll over')
e.add_trick('play dead')
print(d.tricks)   # ['roll over']
print(e.tricks)   # ['play dead']



# 如果同样的属性名称同时出现在实例和类中，则属性查找会优先选择实例:
class Warehouse:
   purpose = 'storage'
   region = 'west'

w1 = Warehouse()
print(w1.purpose, w1.region)  # storage west
w2 = Warehouse()
w2.region = 'east'
print(w2.purpose, w2.region)  # storage east

• 私有变量的名称改写

由于存在对于类私有成员的有效使用场景（例如避免名称与子类所定义的名称相冲突），因此存在对此种机制的有限支持，称为名称改写。 任何形式为 __spam 的标识符（至少带有两个前缀下划线，至多一个后缀下划线）的文本将被替换为 _classname__spam

class Donkey:
    __age = 18
    _name = 'grig'
    gender_ = '男'
    __hometown_ = '宜宾'
    __height__ = '160cm'

    def update(self):
        print(f'Donkey\'update')

    __update = update


class SubDonkey(Donkey):
    def update(self):
        print(f'SubDonkey\'update')

    __update = update


sb = SubDonkey()
sb.__update()  # AttributeError: 'SubDonkey' object has no attribute '__update'AttributeError: 'SubDonkey' object has no attribute '__update'
sb._Donkey__update()  # Donkey'update         【发生名称改写】
sb.__update()  # AttributeError: 'SubDonkey' object has no attribute '__update'
sb._SubDonkey__update()  # SubDonkey'update      【发生名称改写】
print(sb._Donkey__age)  # 18   【发生名称改写】
print(sb._name)  # grig      【未发生名称改写】
print(sb.gender_)  # 男     【未发生名称改写】
print(sb._Donkey__hometown_)  # 宜宾    【发生名称改写】
print(sb.__height__)  # 160cm     【未发生名称改写】

• 将一些带名称的数据项捆绑在一起。 实现这一目标的理想方式是使用 dataclasses

class Employee:
    name: str
    dept: str
    salary: int


emp = Employee('grig', 'clab', 1800)    # TypeError: Employee() takes no arguments


# 使用 dataclasses
from dataclasses import dataclass


@dataclass
class Employee:
    name: str
    dept: str
    salary: int


emp = Employee('grig', 'clab', 1800)    # TypeError: Employee() takes no arguments
emp.name = 'Bob'

print(emp.name)     # Bob
print(emp.salary)   # 1800

• 文件通配符

glob 模块提供了一个在目录中使用通配符搜索创建文件列表的函数

import glob
print(glob.glob('*.py'))    # ['primes.py', 'random.py', 'quote.py']

• 对于日常文件和目录管理任务， shutil 模块提供了更易于使用的更高级别的接口:

import shutil
shutil.copyfile('data.db', 'archive.db')
shutil.move('/build/executables', 'installdir')

• 命令行参数

命令行参数以列表形式存储在 sys 模块的 argv 属性中

import sys
print(sys.argv)

在命令行中运行 python demo.py one two three 输出的结果

['demo.py', 'one', 'two', 'three']

argparse 模块提供了一种更复杂的机制来处理命令行参数

import argparse

parser = argparse.ArgumentParser(
    prog='top',
    description='Show top lines from each file')
parser.add_argument('filenames', nargs='+')
parser.add_argument('-l', '--lines', type=int, default=10)
args = parser.parse_args()
print(args)

• statistics 模块计算数值数据的基本统计属性（均值，中位数，方差等）

import statistics
data = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5]
print(statistics.mean(data)) # 1.6071428571428572
print(statistics.median(data)) # 1.25
print(statistics.variance(data)) # 1.3720238095238095

• doctest 模块提供了一个工具，用于扫描模块并验证程序文档字符串中嵌入的测试

def average(values):
    """Computes the arithmetic mean of a list of numbers.
    
    >>> print(average([20, 30, 70]))
    40.0
    >>> print(average((1,2,3)))
    2.0
    """
    return sum(values) / len(values)


import doctest

doctest.testmod()

• jsonpath 的使用

参考链接

from jsonpath import jsonpath

d = {
    'status_code':200,
    'desc':'成功',
    'data':[
        '123',
        '345',
        789
    ]
}

print(jsonpath(d,'$.desc'))       # ['成功']
print(jsonpath(d,'$.data[3]'))    # False

• python 查用字符

whitespace = ' \t\n\r\v\f'
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_letters = ascii_lowercase + ascii_uppercase
digits = '0123456789'
hexdigits = digits + 'abcdef' + 'ABCDEF'
octdigits = '01234567'
punctuation = r"""!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"""
printable = digits + ascii_letters + punctuation + whitespace

• ASCII码与字符相互转换

c = 'a'
a = 101
print( c + " 的ASCII 码为", ord(c))   # a 的ASCII 码为 97
print( a , " 对应的字符为", chr(a))   # 101  对应的字符为 e

• 解包

lst = [1, 2]
m1, n1 = lst
print(m1)  # 1
print(n1)  # 2

dic = {
    "ka": 123,
    "kb": 234
}
m2, n2 = dic
print(m2)  # ka
print(n2)  # kb

st = {1, 2}
m3, n3 = st
print(m3)  # 1
print(n3)  # 2

tup = (1, 2)
m4, n4 = tup
print(m4)  # 1
print(n4)  # 2


tup = [1, 2, 3]
m5, n5 = tup
print(m5)  # ValueError: too many values to unpack (expected 2)，字典、集合、元组等也存在这个现象，要求参数个数需要和可迭代对象的元素个数相同

• 去除小数位后的零

a = 12.12300  # 目标结果要求为12.123
b = 12.00  # 目标结果为12
c = 200.12000  # 目标结果为200.12
d = 200.10  # 目标结果为200
e = 11.0    # 目标结果为 11

# 如果直接用str方法，不能达到目的
print(str(a))   # 12.123
print(str(b))   # 12.0
print(str(c))   # 200.12
print(str(d))   # 200.1
print(str(e))   # 11.0

# 使用列表推导式+条件索引可以达到目的
print([str(a),int(a)][int(a)==a])   # 12.123
print([str(b),int(b)][int(b)==b])   # 12
print([str(c),int(c)][int(c)==c])   # 200.12
print([str(d),int(d)][int(d)==d])   # 200.1
print([str(e),int(e)][int(e)==e])   # 11

• 打印列表时，不显示引号

lst = ['1', '2.3', '6']
# 直接打印，显示引号
print(lst)  # ['1','2.3','6']

# 打印不显示引号

print('[' + ', '.join(lst) + ']')   # [1, 2.3, 6]