with open(filename, mode, encoding) as fp:
    # 这里写通过文件对象fp读写文件内容的语句

with open('test.txt', 'r') as src, open('test_new.txt', 'w') as dst:
    dst.write(src.read())

import pickle

i = 13000000
a = 99.056
s = '中国人民123abc'
lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
tu = (-5, 10, 8)
coll = {4, 5, 6}
dic = {'a':'apple', 'b':'banana', 'g':'grape', 'o':'orange'}
data = [i, a, s, lst, tu, coll, dic]

with open('sample_pickle.dat', 'wb') as f:
    try:
         pickle.dump(len(data), f) #表示后面将要写入的数据个数
         for item in data:
              pickle.dump(item, f)
    except:
        print('写文件异常!')        #如果写文件异常则跳到此处执行

with open('sample_pickle.dat', 'rb') as f:
    n = pickle.load(f)            #读出文件的数据个数
    for i in range(n):
        x = pickle.load(f)
        print(x)

import struct

n = 1300000000
x = 96.45
b = True
s = 'a1@中国'
sn = struct.pack('if?', n, x, b)       # 序列化
length = len(sn)                       # 序列化后的长度，第14行会用到
with open('sample_struct.dat', 'wb') as fp:
    fp.write(sn)                       # 写入字节串 
    fp.write(s.encode())               # 字符串直接编码为字节串写入

with open('sample_struct.dat', 'rb') as fp:
    sn = fp.read(length)               # 读length个字节
    tu = struct.unpack('if?', sn) 
    print(tu)
    n, x, bl = tu
    print('n=', n)
    print('x=', x)
    print('bl=', bl)
    s = fp.read(9).decode()
    print('s=', s)

'''
(1300000000, 96.44999694824219, True)
n= 1300000000
x= 96.44999694824219
bl= True
s= a1@中国
'''

def f(x=3):
    pass

print(f.__defaults__)  # (3,)

def demo(a, b, c):
    print(a + b + c)

seq = [1, 2, 3]
demo(*seq)

def demo(a, b, c):
    print(a + b + c)

dic = {'a': 1, 'b': 2, 'c': 3}
demo(**dic)

demo(a=1, *(2, 3))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: demo() got multiple values for argument 'a'

demo(b=1, *(2, 3))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: demo() got multiple values for argument 'b'

demo(c=1, *(2, 3))  # ok

demo(**{'a': 1, 'b': 2}, *(3,))
  File "<stdin>", line 1
SyntaxError: iterable argument unpacking follows keyword argument unpacking

demo(*(3,), **{'a': 1, 'b': 2})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: demo() got multiple values for argument 'a'

demo(*(3,), **{'c':1, 'b':2})  # ok

x = 3

def f():
    print(x)
    x = 5
    print(x)

f()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in f
UnboundLocalError: local variable 'x' referenced before assignment

global_variable = 0

import A
A.global_variable = 1
print(A.global_variable)

def scope_test():
    def do_local():
        var = "local variable"

    def do_nonlocal():
        nonlocal var           # 要求var必须是已存在的变量
        var = "nonlocal variable"

    def do_global():
        global var             # 如果全局作用域内没有var，就自动新建一个
        var = "global variable"

    var = "original"
    do_local()
    print("after do_local:", var)
    do_nonlocal()
    print("after do_nonlocal:", var)
    do_global()
    print("after_do_global:", var)

scope_test()
print("global:", var)

# after do_local: original
# after do_nonlocal: nonlocal variable
# after_do_global: nonlocal variable
# global: global variable

x = 3
def outer():
    y = 5

    # 这个自定义函数和内置函数名字相同，会在当前作用域和更内层作用域中影响内置函数map()的正常使用
    def map():
        return 'fake map()'
    
    def inner():
        x = 7
        y = 9
        # 最内层的作用域内，局部变量（Local）x,y优先被访问
        # 在局部域、闭包、全局作用域内都不存在函数max，最后在内置作用域（Builtin）内搜索到函数max
        # 当前作用域中不存在map，但在外层的闭包作用域内搜索到了，并没有调用内置函数map
        print('inner:', x, y, max(x,y), map())
        
    inner()
    # 在当前作用域（闭包，Enclosing）内，y可以直接访问
    # 当在当前作用域内不存在x，继续到全局作用域（Global）去搜索
    # 当前作用域内不存在函数max，外层全局作用域也不存在，最后在内置作用域（Builtin）内搜索到函数max
    # 当前作用域中有个map，直接调用了，没有调用内置函数map
    print('outer:', x, y, max(x,y), map())
    
outer()
# 当前作用域中有x，可以直接访问，但不存在y
# 由于当前处于全局作用域，按Python变量搜索顺序，会继续在内置作用域搜索
# 不会去搜索Enclosing和Local作用域，但在内置作用域内也不存在y，代码引发异常
print('outside:', x, y, max(x,y))

def f():
    for i in range(10):
        yield i

try:
    a = f()
    print(a)
    while True:
        print(next(a), end = ' ')
except StopIteration:
    pass

# <generator object f at 0x0000017AFC12BA50>
# 0 1 2 3 4 5 6 7 8 9

def f():
    yield from 'abcdefghijklmnopqrstuvwxyz'

try:
    a = f()
    print(a)
    while True:
        print(next(a), end = ' ')
except StopIteration:
    pass

# <generator object f at 0x000002B26498BA50>
# a b c d e f g h i j k l m n o p q r s t u v w x y z

def f():
    yield 1
    yield 2
    yield 3

a, b, c = f()
print(a, b, c)

def before(func):
    def wrapper(*args, **kwargs):
        print('Before function')
        return func(*args, **kwargs)
    return wrapper

def after(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        print('After function')
        return result
    return wrapper

@before
@after
def test():
    print(3)

test()

# Before function
# 3
# After function

def add3(a, b, c):
    return a + b + c

def add2(a, c):
    return add3(a, 3, c)

print(add2(1, 1))

from functools import partial

add2 = partial(add3, b=3)
print(add2(a=1, c=1))

a = 3 + 4j
b = 5 + 6j
c = a + b
print(c)  # (8+10j)
print(c.real, c.imag, c.conjugate())  # 8.0 10.0 (8-10j)

# Python 3.6.x开始支持在数字中间位置使用单个下划线作为分隔来提高
# 数字的可读性，类似于数学上使用逗号作为千位分隔符。

print(1_000_000)   # 1000000
print(1_2_3_4)     # 1234
print(1_2 + 3_4j)  # (12+34j)
print(1_2.3_45)    # 12.345

a = 2
print(~a)  # -3
# 2的二进制表示为 010，其中最高位为符号位
# 取反得 101，将其取反+1可以得到它对应的正数 011，即 +3
# 所以补码 101 为 -3，即上述 print 结果。

>>> {1, 2, 3} | {3, 4, 5}         # 并集，自动去除重复元素 a.union(b)
{1, 2, 3, 4, 5}
>>> {1, 2, 3} & {3, 4, 5}         # 交集 a.intersection(b)
{3}
>>> {1, 2, 3} ^ {3, 4, 5}         # 对称差集 a.symmetric_difference(b)
{1, 2, 4, 5}
>>> {1, 2, 3} - {3, 4, 5}         # 差集 a.difference(b)
{1, 2}

class Test:
    def __matmul__(self, value):
        print('__matmul__', value)
        return self

    def __rmatmul__(self, value):
        print('__rmatmul__', value)
        return self

    def __imatmul__(self, value):
        print('__imatmul__', value)
        return self


a = Test()
b = Test()
c = a @ b  # __matmul__ <__main__.Test object at 0x000001E098F8A2E0>
d = 1 @ a  # __rmatmul__ 1
e = a @ 2  # __matmul__ 2
c @= c     # __imatmul__ <__main__.Test object at 0x000001E098F2A550>
d @= 3     # __imatmul__ 3

import numpy as np
x = np.ones(3)
y = np.eye(3) * 3
y[0, 2] = 5
y[2, 0] = 3
print(x @ y)  # [6. 3. 8.]