1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

from time import time

# 这是一个装饰器函数
def timer(func):
    def wrapper():
        start = time()
        func()
        end = time()
        print(f"{func.__name__}运行时间:{end - start}")
    return wrapper

# 使用装饰器  
@timer
def foo():
    print("foo函数运行中...")
    for i in range(10000):
        i ** 2

foo()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

result = []
temp = ""
twitter = ["0_7_15_0_14_7_21", "-13_11_15", "-13_11_20", "-14_27"]
# x是字符串
for x in twitter:
    # 不能使用twitter[x], 报错list indices must be integers or slices not str
    numbers = x.split('_')
    for y in numbers:
        temp += chr(90 + int(y))
        result.append(temp)
        

1
2
3
4
5
6
7

def funcA(a, &b):
    print(a, b) 
    b = 20 # 修改b的值

b = 10
funcA(1, b) 
print(b) # 输出20

1
2
3
4
5

def funcB(a, *b):
    print(a, b)

funcB(1) # 1 ()  
funcB(1, 2, 3) # 1 (2, 3)

1
2

// observer是一个指向observer类类型的指针。
observer* observer   

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// enity是一个对Entity类型的常引用。  
// const关键字的作用是使该引用enity成为一个常量引用,无法通过它来修改所引用的对象。  
// 具体来说:
// - Entity& 表示这是一个对Entity对象的引用。
// - const修饰这个引用,使得它成为一个常引用,无法通过它来修改所引用的对象。
// 这样做的好处是:
// 1. 避免通过引用意外修改对象,增强程序健壮性。
// 2. 可以让编译器进行优化,如果函数不修改引用指向的对象,那编译器可以进行一些性能优化。
// 3. 对于类成员,可以在声明时使其成为常引用,防止修改。
// 所以,const的作用是使引用及指针无法修改所指向的对象,起到一个保护对象不被修改的作用
const Entity& enity  

1
2
3
4
5
6

// 定义一个virtual析构可以让子类正确执行析构。
// 所以在C++中,正确使用指针、引用和析构函数对类的设计非常重要。
// 指针用于传递对象地址,提高效率;引用用于避免复制,节省空间;析构用于释放资源。
virtual ~Entity() { 
    // 析构函数代码
}  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

def outer():
    x = 1
    def inner():
        print(x)
        
    return inner 

closure = outer()
closure() # 输出1

# inner函数封闭保存了outer函数的x,所以inner就是一个闭包。
# 我们也可以通过lambda表达式创建闭包:
y = 2 
closure = lambda: print(y)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import sys

# Python还可以通过gc模块手动触发垃圾回收。
a = Object()
print(sys.getrefcount(a)) # 2

b = a 
print(sys.getrefcount(a)) # 3 

del b
print(sys.getrefcount(a)) # 2

del a
# a自动被回收

1
2
3
4
5
6
7

class Parent:
    def public_method(self):
        pass

class Child(Parent):
    # 可以访问public_method
    pass

1
2
3
4
5
6

class Parent:
    def _protected_method(self):
        pass

class Child(Parent):
    # 只可以访问public_method

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

from functools import wraps

# 这里log装饰器在不修改add函数的情况下,为其添加了日志打印功能。
def log(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Call {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@log  
def add(x, y):
    return x + y

add(2, 3)

# 打印:
# Call add
# 5

1
2
3
4
5

import MySQLdb

conn = MySQLdb.connect(host='localhost', user='root', passwd='123456', db='test')
cur = conn.cursor()
cur.execute('select * from tb_user')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = 'user'

    id = Column(Integer, primary_key=True)
    name = Column(String)

1
2
3
4
5

import pymongo

client = pymongo.MongoClient(host='localhost', port=27017)
db = client['testdb']
col = db['user']