#!/usr/bin/python3

if 条件:
    语句
elif 条件:
    语句
else:
    语句

age = 20
match age:
    case x if x < 10: # 满足条件赋值给变量 x
        print(f'< 10 years old: {x}')
    case 10: # 值（可以是任何对象）
        print('10 years old.')
    case 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18: # 条件
        print('11~18 years old.')
    case _: # 其它
        print('not sure.')

while 条件:
    语句

msg="123"+ \ # 多行语句使用 \
    +"45"
for s in msg:
    print(s) # break与continue 控制循环
else:
    # 循环自然结束时执行

# enumerate 返回迭代器(index, value)
for i, v in enumerate(['a', 'b']):
    print(i, v)

for s in range(5):
    print(s,end='')
# 默认从0开始到5但不取5，输出结果：01234

for s in range(2,5):
    print(s,end='')
# 从2到5但不取5，输出结果：234

for s in range(1,5,2):
    print(s,end='')
# 每次步进2位数，输出结果：13

[x * x for x in range(1, 3)] # [1, 4]
[x * x for x in range(1, 3) if x % 2 == 0] # [4]
[m + n for m in '12' for n in '34'] # ['13', '14', '23', '24']

def foo():
    while True:
        res = yield 4
        print("res:",res)
g = foo()
print(next(g)) # 4
print(next(g)) # 4

str='hi'
str="hello"
# 多行字符串
str="""
hello
world\n
"""
# 原始字符串：
str=r"hello world\n" #等于"hello world\\n"

str[0] # 获取单个字符
str[5:] # 切片
str[-10:-1] # 负数则从末尾计数
str[::-1] # 反转字符串

len(str) # 返回字符串长度
str.strip() # 删除开头和结尾的空白字符
str.lower() # 返回小写的字符串
str.upper() # 返回大写的字符串
str.swapcase() # 切换大小写
str.replace('hello','hi') # 返回替换后的字符串
str.split('\n',num) # 返回按指定分隔符分隔的列表,num为分隔次数默认-1分隔全部
print("hello" in str) # 查看某字符串是否存在此字符串中
print("hello" not in str) # 与not搭配使用
str.capitalize() # 首字母大写，其他字母变小写

str.count("str") # 某字符串出现的次数
# find与index类似，查找某串在字符串中的位置
print(str.find("w")) # find(value, [[start], end])
print(str.index("w")) # 未查找到时：find方法返回 -1，index方法将引发异常

str.startswith(substr, beg, end) # 是否以指定子字符串开头
str.endswith(suffix, beg, end) # 是否以指定子字符串结束

"123abc".isalnum() # 字符串中的字符是否都是字母或数字
"abc".isalpha() # 字符串中的字符是否都是字母
"123".isdigit() # 字符串中的字符是否都是数字

# join按指定分隔符将可迭代对象中的元素，连接为一个字符串
lists=("1","2","3")
print("-".join(lists)) # 1-2-3
d={"name":"ruoxi","value":"123"}
print("+".join(d)) # name+value key的组合字符串

# format 方法格式化
print("{}hello{}world".format(1,"ha"))
print("{1}hello{0}world{0}".format(1,"ha"))
print("{a}hello{b}world{a}".format(a=1,b="ha"))

# f-string 格式化字符串,f'{表达式}'
f'Hello {name}'

# 通过字典设置参数
site = {"name": "name", "url": "www"}
print("网站名：{name}, 地址 {url}".format(**site))
# 通过列表索引设置参数
lists=['name', 'www']
print("网站名：{0[0]}, 地址 {0[1]}".format(lists))  # "0" 是必须的
# 还可传入一个对象
print('value 为: {0.value}'.format(obj))

# 格式化数字
print("{0:.2f}".format(3.1415926)) # 保留小数点后两位(为0表示不要小数)
print("{0:+.2f}".format(3.1415926)) # 带符号保留小数点后两位
print("{:0>2d}".format(3)) # 数字补零(填充左边,宽度为2)
print("{0:x<4d}".format(3)) # 数字补零(填充左边,宽度为2)

# %操作符格式化：
# 使用格式：%[(key)][+:右对齐,-:左对齐,0:0填充][字符宽度].[小数位]类型
print("%dhello world%s"%(12,1234)) #元组方式
print("%(key1)d hi world %(key2)s" % {'key1':12,'key2':123}) # 字典方式
print("%-4d" % 5) # 单个元素无须括号包裹
print("%+8.3f" % 2.3)
# 常用类型：%s字符串，%b二进制整数，%d十进制整数
# %o八进制整数，%x十六进制整数，%f浮点数，%%字符"%"

lists1=[0,'1',"2",[3,4,5]]
lists2=['str','hi']
print(lists2[1])
print(lists1)
print(lists1+lists2)

lists2.append("world") # 添加
print(len(lists2)) #长度
lists2.extend(['list']) # 将另一列表元素添加到此列表
lists2.insert(1,'hello') # 插入从0开始
lists2.remove('str') # 移除一个指定元素
lists2.pop() # 移除最后一个元素并返回
lists2.pop(1) # 指定位置移除并返回此元素
lists2.sort() # 对列表元素排序(默认升序)
lists2.reverse() # 将现列表反序
lists1.count('2') # 统计某元素出现的次数
lists1.index('2') # 查找元素
lists1.index('2',1,4) # 指定位置开始在某范围内查找
print(lists2)
print('2' in lists1) # 查找元素是否存在某元素中
list.sort() # 对列表排序
list.reverse() # 反转列表
list.copy() # 复制列表
lists1.clear() # 清空列表
del lists1[0] # 删除元素

numbers = [1, 2, 3, 4, 5]
map(lambda x: x**2, numbers) # 映射

filter(lambda x: x % 2 == 0, numbers) # 过滤

from functools import reduce
reduce(lambda x, y: x * y, numbers) # 归纳

lists1[:] # 复制此列表返回
lists1[:3] # 从头取到3的前一个元素
lists1[1:] # 从1取到最后一个元素
lists1[2:3] # :后的数字在列表长度内不取，大于列表长度将取到最后一位
lists1[::-1] # 反转数据(反转字符串同理)

t1=(0,'1',"2",[3,4,5])
t2=('str','hi')
print(t1+t2)

num=(1) # 普通数字
t3=(1,) # 元组
t4=1,2 # 有多个元素时不用括号也表示元组

(list1,list2)=("1","2") # 将序列元素赋值给指定变量,列表同([])
print(list1,list2) # 输出：1 2

str="hello"
print(list()) # 返回一个空列表，tuple同
print(list(str)) # 将一个序列元素变为列表
print(tuple(str)) # 将一个序列元素变为列表
print(tuple(list(str))) # 因为list和tuple都是序列可以相互转换
len(tuple(str)) # 返回长度

# 序列中数字和字符串同时存在时使用max或min将报错
print(max(list(str))) # 返回序列中的最大值，max(str)同
min(str) # 最小值同理
sum((1,2,3,4)) # 对数字序列求和(参2可选再加上一数)

list(reversed(str)) # 返回一个反转的迭代器，序列对象可接受并转换
# 将序列组合为一个索引序列，同时列出数据和数据下标，返回enumerate(枚举)对象
print(list(enumerate(str))) # 运行结果：((0, 'h'), (1, 'e'), (2, 'l'), (3, 'l'), (4, 'o'))

# 将序列中对应的元素打包成一个个元组，然后返回由这些元组组成的对象
a=(1,2,3,4) # 4在b中没有对应元素，将被舍去
b=("一","二","三")
print(list(zip(a,b))) # 运行结果：[(1, '一'), (2, '二'), (3, '三')]

import random
random.randint(1,10) # 生成随机数
random.shuffle(lst) # 将序列的所有元素随机排序
random.choice(seq) # 从序列中随机挑选一个元素
random.sample(range(100), 10) # 从指定序列中随机获取指定长度的片断并随机排列

# 定义集合
sets={"set1","set2"}
set(sets) # 接受一个可迭代序列转集合，空参为空集合
set() # 空集合必须使用 set()，{} 表示空字典
print(sets)
for item in sets: # 遍历集合
    print("iemt : "+item)
print("set2" in sets) # 查看某元素是否存在

# 集合运算：
a=set('abc') # {'a', 'c', 'b'}
b=set('bcd') # {'d', 'c', 'b'}
print(a - b) # a包含b不包含的元素(a独有或删除a中b存在的元素)
print(a | b) # ab 中所有的元素
print(a & b) # ab 同时包含的元素
print(a ^ b) # ab 中它们独有的元素

sets=set("abcde")
len(sets) # 集合个数
print('a' in sets) # 判断元素是否存在此集合中
sets.copy() # 拷贝此集合
sets.clear() # 清空集合

# 添加元素：
sets.add("a") # 添加一个元素
# 另一种添加元素方式，可传入可迭代元素(包括字典保存它的key)
sets.update({'b':'2','c':'3'},'e',[1,2])

# 移除元素：
sets.remove("a") # 移除元素并返回，元素不存在则报错
sets.discard("f") # 移除指定元素不存在时不会报错
sets.pop() # 随机移除元素并返回

a={1,2,3}
b={1,2}
a.isdisjoint(b) # 集合是否没有相同元素
a.issuperset(b) # 集合是否是某集合的父集
b.issubset(a) # 集合是否是某集合的子集

# 字典创建key唯一，可以是字符串，数字，元组
d={'a':1,2:2,(1,2):3} # 字典值可以是任何对象
print(d[(1,2)]) # 可以通过键访问和修改值
print("a" in d) # 查看某键是否存在此字典中
d["b"]='b' # 当key不存在时会自动创建
del d['a'] # 删除某元素
len(d) # 元素个数

d.get("a",False) # 根据key获取值不存在时，返回参2的值默认为None
d.setdefault('c','c') # 与get一样，不存在时创建并赋参2值
d.update({'b':'c','d':'d'}) # 将传入的字典数据都添加到此字典中
d.pop('b',False) # 删除指定key，不存在时返回参2值或参2不写将报错
d.popitem() # 删除并返回最后一组键值对组成元组
d.copy() # 返回此字典的拷贝

d.keys() # 返回此字典key的迭代器(可用list()转换为列表)
d.values() # 返回values的迭代器(可list())
d.items() # 返回键值对元组，组成的列表:[(键，值)]
d.clear() # 清空字典

t=(1,2,3) # 创建序列作为key
d=d.fromkeys(t,'def') # 创建一个新字典，参2为值(默认None)
print(d) # {1: 'def', 2: 'def', 3: 'def'}
for k, v in d.items(): # for + items 遍历
    print(k, '=', v)
del d # 删除字典

from datetime import datetime

datetime.now() # 获取当前 datetime
# {day, month, year, hour, minute} # 等常见属性
# 用指定日期时间创建 datetime(y, m, d)
datetime(2024, 3, 4, 13, 11, 56, 654634)
datetime.now().timestamp() # 时间戳
datetime.fromtimestamp(t) # 时间戳转 datetime
# str 转换为 datetime
datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
# datetime 格式化为 str
datetime.now().strftime('%Y-%m-%d %H:%M:%S')
datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3] # 毫秒级
datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f') # 微秒级

# datetime 支持直接加减运算
from datetime import datetime, timedelta, timezone
now = datetime.now()
now + timedelta(days=2, hours=12) # 加减指定天或小时
# 当前东八区时间（上海）
datetime.now().astimezone(timezone(timedelta(hours=8))).strftime('%Y-%m-%d %H:%M:%S')

# 当前时间上海时区
import pytz
datetime.now(pytz.timezone('Asia/Shanghai')).strftime("%Y-%m-%d %H:%M:%S")

def fun(name="long",value="yes",*var):
    '函数第一行字符串作为函数的文档，通过help方法可以查看'
    print(name+value)
    for s in var: # '*':任意参数接受到的值将组成一个元组
        print(s)
    return name #返回值

# 只有运行当前模块(当前的 .py 文件) help 才会执行
if __name__ == '__main__':
    help(fun) # 查看函数文档
fun(value="ha",name="zhang") # 关键字传参(不能传入任意参数的值)
fun("1","2",1,2) # 1，2 作为任意参数组成元组传入

# 任意参数后还有参数时必须用关键字传参
def fun2(*var,str="s"):
    for s in var:
        print(s)
    print(str)
fun2(1,str="ha") # 使用关键字传参给任意参数后面的参数传参

def person(name, *, city): # * 后面的参数必须用关键字传参
    pass
person('Jack', city='Beijing') # 传入参数时必须指定参数名

# global：修饰全局变量：
def fun():
    # 在函数内改变外部变量需要加 global 关键字
    global count # 去掉此句 count 将是一个局部变量
    count=2
    print("fun() = %d"%count)
count =1
fun() # 输出：fun() = 2
print("main() = %d"%count) # 输出：main() = 2

# nonlocal 修饰外层变量：
def func1():
    x=2
    def func2(): # 函数内部可嵌套函数
        nonlocal x # 修饰为外部变量，去除此句将报错
        x *=x
        print(x)
    return func2() # 返回内部函数
func1() # 输出：4

# lambda 表达式：
def f1(): # lambda 表达式可以简写此方法
    return 1
# 使用方法：'lambda 参数(多个用逗号隔开): 返回值表达式'
f=lambda : 1 # 它返回的只是一个函数对象
print(f())
sum = lambda arg1, arg2: arg1 + arg2
print(sum( 10, 20 ))

def person(name, age, **kw): # 关键字参数自动组装为一个 dict
    pass
person('Adam', 45, gender='M') # kw = {'gender': 'M'}
extra = {'city': 'Beijing'}
person('Jack', 24, **extra) # kw = {'city': 'Beijing'}

f = open("E:/test/str.txt","r",encoding='utf-8') # 1文件路径名 2文件打开模式 3编码格式
print(f.closed, f.name, f.mode) # 文件是否关闭，文件名，模式

f.read() # 传入int参数从文件读取指定的字节数，如果未给定或为负则读取所有
f.readline() # 读取整行，包括"\n"字符(也可传入int指定字节数)
f.readlines() # 读取所有行(直到结束符EOF)并返回列表

f.write(str) # 将字符串写入文件，返回的是写入的字符长度
f.writelines(['第一行\n','第二行']) # 写入序列字符串列表，换行需要自己加入每行的换行符

f.tell() # 返回文件当前指针位置

# seek参1：移动的字节数，是负数表示从倒数第几位开始
# seek参2：0(默认) 从文件头，1 从当前位置，2 从文件末尾
f.seek() # 移动指针，成功返回新位置，失败返回-1

# truncate：从文件首字节开始截断，截断文件为参1个字节，无参表示从当前位置截断
# 必须在能写模式下，`r` 下模式建议使用 `r+`
# 读取模式下截断后不能继续读取，否则数据将不会被删除
f.truncate() # 截断数据，其它数据将被删除

f.flush() # 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件
f.close() # 关闭文件

import json

person = { "name": "Asabeneh" }
with open('json_file.json', 'w', encoding='utf-8') as f:
    json.dump(person, f, ensure_ascii=False, indent=4)

import os # 导入模块

print(os.sep) # 系统路径分隔符
print(os.linesep) # 系统行终止符
print(os.name) # 工作平台:Windows='nt'，Linux/Unix='posix'
print(os.curdir) # 当前目录："."

os.getcwd() # 当前工作目录
os.chdir("e:"+ os.sep) # 改变当前工作目录
os.system('cmd') # 运行shell命令
os.stat(r'E:\test\test.txt') # 获得文件属性

os.rename(src, dst) # 重命名文件
os.renames(old, new) # 递归重命名文件

os.listdir() # 返回目录下文件和文件夹名的列表(可传入路径字符串指定目录)
os.scandir() # 返回迭代器，包含目录中的文件信息
os.walk() # 返回迭代器，包含目录中的文件信息，还包含子目录信息

os.mkdir(path) # 创建一个文件夹，路径错误会文件夹已存在将报错
os.makedirs(path) # 创建多级目录，目录所有目录已存在将报错

os.remove(path) # 删除文件，文件不存在会报错
os.rmdir(path) # 删除一个空文件夹，非空或不存在会报错
os.removedirs(path) # 删除目录(多个文件夹)，非空报错

import os
file = "e:/test/test.txt"

os.path.abspath(".") # 返回指定路径的绝对路径
os.path.basename(".") # 返回文件名
os.path.dirname(file) # 传入路径的路径名(去除文件名)
os.path.split(file) # 分割文件和路径名组成元组
os.path.splitext(file) # 分割路径文件名和文件扩展名
os.path.join("e:\\","test","test.txt") # 组合路径名(cde等主盘路径不会加反斜杠)

os.path.getatime(file) # 最近访问时间
os.path.getctime(file) # 创建时间
os.path.getmtime(file) # 最近修改时间(可time.gmtime(tiem)查看时间)
os.path.getsize(file) # 文件大小(字节)，文件不存在报错
os.path.exists(file) # 判断路径是否存在

os.path.isabs(file) # 是否为绝对路径
os.path.isdir(file) # 是否为目录
os.path.isfile(file) # 是否为文件
os.path.islink(file) # 是否为连接
os.path.ismount(file) # 是否为挂载点(如'c:')

import shutil
shutil.copy(src, dst) # 复制文件
shutil.copytree(src, dst) # 复制文件夹
shutil.move(src, dst) # 移动文件(夹)
shutil.rmtree(src) # 递归删除文件夹

try:
    # 语句执行区域
    raise Exception # 抛出一个异常
except OSError as err: # 捕获指定异常
    print("OS error: {0}".format(err))
except:
    print("except") # 异常发生语句执行区
    raise # 不想或无法处理的异常继续抛出
else:
    print("else") # 无异常语句执行区
finally:
    print("finally") # 必执行语句区

# with 关键字无论文件是否打开成功，不再使用后都会关闭
with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

class MyError(Exception): # 继承 Exception 异常类
        def __init__(self, value):
            self.value = value
        def __str__(self):
            return repr(self.value)

raise MyError("my define error") # 抛出自定义异常

class Class(object): # 括号内表示继承类，多继承可逗号隔开
    name='' # 定义类元素
    __weight=0 # 定义私有属性(私有方法同理)
    def __init__(self,name): # 构造函数
        Class.name="hi" # 定义或对类元素赋值
        self.name=name # 对实例元素name赋值
        self.age=10
    def show(self): # self 表示当前实例对象类似(this)
        print('name=',self.name,',age=',self.age)

c=Class('world') # 创建实例对象
c.show() # 调用方法
Class.name="Class" # 创建或改变类属性值
c.name="self" # 创建或改变实例属性值
print(Class.name) # 访问类属性(实例属性同理)

class Class2(Class): # 继承上 Class 类
    def __init__(self,name): # 子类构造方法也会覆盖父类构造方法，需要自行调用父类构造方法
        super().__init__(name) # 调用父类构造方法(调用父类其它方法同理)
    def show(self): # 重写父类方法
        print(self.name)

    # 静态方法
    @staticmethod
    def sm():
        pass
    # 类方法
    @classmethod
    def cm(cls):
        print("cm")

c2=Class2("Class2")
c2.show()
# c2.show='a' # 定义属性与方法名同时属性将覆盖方法，调用方法将报错

issubclass(Class2,Class) # 参1(类)是否为参2(类)的子类
isinstance(c,Class) # 参1(实例)是否为参2(类)的实例

# 对类或实例的属性操作方法
hasattr(Class,"name") # 参1(类)是否存在参2属性
hasattr(c,"name") # 实例同理
getattr(Class,"name") # 获取某属性
setattr(Class,"name","value") # 添加或设置某属性值
delattr(Class,"name") # 删除某属性(还可使用del关键字)

class Test:
    def __init__(self): # 初始化
        self.num=1
    def __str__(self): # 类似tostring方法
        return str(self.num)
    def __del__(self): # 实例被删除(del)时调用
        print("实例被del")

    def getnum(self):
        return self.num
    def setnum(self,num):
        self.num=num
    def delnum(self):
        del self.num
    x=property(getnum,setnum,delnum) # 对该属性的操作将调用不同的方法

test=Test()
print(test) # 调用tostring方法

print(test.x) # 调用get方法
test.x=30 # 调用set方法
print(test)
del test.x # 调用del方法
del test

import numpy as np

data = np.array([[1, 2, 3, 4], [4, 5, 6, 7]])
data = np.zeros(shape=(5, 3))  # 5行3列,全0数组
data = np.ones(shape=(5, 3))  # 全1数组
data = np.empty(shape=(5, 3))  # 空数组

data = np.arange(1, 10, 2)  # 1-10的数据，步长为2
data = np.linspace(1, 10, 20)  # 开始端1，结束端10，且分割成20个数据
data = np.random.rand(3, 4)  # 3行4列的随机数组
data = np.random.randint(2, 5, size=(4, 5))

# 垂直堆叠
stacked_vertically = np.vstack((array1, array2))
# 水平堆叠
stacked_horizontally = np.hstack((array1, array2))

data = data.reshape((4, 5))  # 改变数组形状
data.shape  # 获取数组形状
data.size  # 获取数组元素个数
data.ndim  # 获取数组的维度
data.dtype  # 获取数组数据类型

# 数组可以与数字或数组进行数学运算
data = np.random.randint(2, 5, size=(4, 5))
data2 = np.random.randint(2, 5, size=(4, 5))
print(data, data + 1)
print(data + data2)

arr_min = np.min(data)  # 求最小值
arr_max = np.max(data)  # 求最大值
arr_sum = np.sum(data)  # 求和
prod = np.prod(data)  # 求积
mindle = np.mean(data)  # 求平均值
median = np.median(data)  # 求中位数
std = np.std(data)  # 求标准差
var = np.var(data)  # 求方差

data = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(data[0:1])  # [[[1, 2], [3, 4]]] 第一行
print(data[0:1, 0:1])  # [[[1, 2]]] 第一行内的第一行
# 列切片以 [:,] 开始
print(data[:, 0:1])  # [[[1, 2], [5, 6]]] 第一列

import numpy as np
import pandas as pd

# series 一维数组结构
s = pd.Series([1, 2, 3, 5, 6])
# dataframe 二维数组结构
dates = pd.date_range("20130101", periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list("ABCD"))
df2 = pd.DataFrame(
    { # 键是列标签，值是列值
        "A": 1.0,
        "B": pd.Timestamp("20130102"),
        "C": pd.Series(1, index=list(range(4)), dtype="float32"),
        "D": np.array([3] * 4, dtype="int32"),
        "E": pd.Categorical(["test", "train", "test", "train"]),
        "F": "foo",
    }
)

df2.dtypes  # 查看数据类型
df.index  # 查看索引标签
df.columns  # 查看列标签
df.T  # 转置(交换行列)
df.head()  # 查看前几行
df.tail(3)  # 查看后几行
df.to_numpy()
df.describe()  # 查看数据描述
df.sort_index(axis=1, ascending=False)  # 按轴排序
df.sort_values(by="B")  # 按值排序

from matplotlib import pyplot as plt
import random

x = range(5)
y = lambda: [random.randint(0, 6) for i in range(5)]

plt.figure(figsize=(20, 8), dpi=80)  # 如果设置画布大小,需要在画图之前
# 绘制折线图
plt.plot(x, y(), label="1", color="red", linestyle="dashed", linewidth=2, alpha=0.5)
plt.plot(x, y(), label="2")

plt.scatter(x, y())  # 绘制散点图
plt.bar(x, y(), width=0.02)  # 绘制柱形图
plt.barh(x, y(), height=0.02)  # 绘制水平柱形图
plt.legend(loc="upper left")  # 设置图例的位置

# 设置x轴刻度(刻度列表, 标签列表), rotation: 旋转角度
plt.xticks(x, ["x-" + str(i) for i in x], rotation=45)
# 设置y轴刻度,与上同理
plt.yticks(range(0, 10), ["y-" + str(i) for i in range(0, 10)])
plt.grid(alpha=0.5)  # 设置网格

plt.title("Title")
plt.xlabel("xLabel")  # 设置x轴名称
plt.ylabel("yLabel")  # 设置y轴名称

plt.savefig("test.svg") # 保存为指定格式的图片
plt.show()  # 显示