type hints之Optional、Union

*和**：*将传进来的作为一个元组，**将传进来的参数作为一个字典

from typing import Union,Optional
# Union[xx,]表示多种选择
# Optional[xx]相当于Union[xx,None]
# Optional[xx]与默认参数是不同的
def test_func(x : Union[str,list]) -> Union[str,list]:
    print(x)
    return x
test_func("aaa")
def test_func_2(x:Optional[str]):
    if x is None:
        print("None")
    else:
        print(x)
test_func_2(None)
def test_func_3(x:Optional[str]=None):
    print("Hello world!")
test_func_3()
def test_func_4(*argv):
    print(argv)
test_func_4(1,2,3,4,5)
def test_func_5(*argv,**kargv):
    print(argv)
    print(kargv)
test_func_5(1,2,3,4,a=1,b=2,c=3)
数据类型和变量
 
整数（int）、浮点数（float）、复数（complex）、字符串（str)、布尔值和空值
 
test_int = 1
test_float = 1.0
test_str = "abc"
test_complex = complex(1,2)
test_bool_1 = True
test_bool_2 = False
test_none = None
#str还有各种函数
str.split()
str.join()
元组（tuple）、列表（list）、字典（dict）、集合（set）
 
#元组不可变
test_tupble = (1,2,3)
test_list = [1,2,3]
test_dict = {"a":1,"b":2}
#空集合必须使用 test_set = set(),test_set = {}会解析成空字典
test_set = {"a","b","c"} 
#集合之前的并集、交集、差集运算，需要转换成set类型
#并集、交集、差集
test_1.union(test_list)
test_1.intersection(test_list)
test_1.difference(test_list)
 
相关函数说明
 
数组排序：sorted
(很多自带sort函数，sort函数是在原数组上排序）
长度可以使用：len()
字符串格式化："{},{}".format("a","b")
插入元素：有顺序的（list）:append,insert
无顺序概念的（set）:add
类自带的函数（__xxx__格式，一般都是函数，所以调用的时候一般是__xxx__()）：__len__()
删掉元素：pop,remove()
还有： del xx[]
test_tuple = (1,2,3)
print(len(test_tuple))
print(test_tuple.__len__())
 
lambda、zip、map、reduce、enumerate函数
 
from functools import reduce
test_list_1 = ['a','b','c']
test_list_2 = [1,2,3]
# zip
for index,value in zip(test_list_2,test_list_1):
    print(index,value)
# enumerate
for index,value in enumerate(test_list_1):
    print(index,value)
#reduce
test_reduce = reduce(lambda x,y:x+y,test_list_2)
print(test_reduce)
#lambda map    
test_map = map(lambda x:x*2,test_list_2)
_xx、__xxx、__xxx__的区别
 
class TestClass():
    _xx:Python中不存在真正的私有方法。为了实现类似于c++中私有方法，可以在类的方法或属性前加一个“_”单下划线，意味着该方法或属性不应该去调用，它并不属于API。
    __xx:它并不是用来标识一个方法或属性是私有的，真正作用是用来避免子类覆盖其内容。编译时会变成 _A__method()
    __XX__:用于python调用，不要使用
    def __init__(self):
        self._test_a = 1
    def __method(self):
        print("This method from A！")
    def method(self):
        self.__method()
 
类、函数定义、异常处理
 
class TestClass():
    def __init__(self):
        self.test_x = 1
    def test_exception(self):
            print("aaa")
            raise ValueError("value error")
        except ValueError as e:
            print(e)
        finally:
            print("try except finally example!")
test_class = TestClass()
test_class.test_exception()
 
file_name = "test.txt"
    f = open(file_name,"w+",encoding="utf-8")
    for line in f.readlines():
        print(line)
    test_write = "测试写入数据"
    f.write(test_write)
    f.close()
except Exception as e: 
    print("exception:",e)
finally:
    if f:
        f.close()
    with open(file_name,"w+",encoding='utf-8') as f:
         for line in f.readlines():
                print(line)
except Exception as e:
    print("exception:",e)
 
序列化：joblib和pickle、json
 
#joblib sklearn自带的，更加高效,joblib没有序列成字符串的功能
#pickle序列化二进制文件，一般序列化只能在python中使用
#json 则是序列化成字符串，外界可以直接使用
import joblib
import pickle
file_path = "xxxxx"
joblib.load(file_path)
joblib.dump(file_path)
#pickle
f = open("file_path",'rb')
d = pickle.load(f)
f.close()
#存储到文件中
f = open("file_path","wb")
pickle.dump(d,f)
f.close()
#dumps序列化成字符串
d= dict(name="bob",age=20)
d_b = pickle.dumps(d)
d = pickle.loads(d_b)
 
os和sys模块
 
import os
import sys
# os指跟操作系统相关的，实际存在的，比如文件路径、目录
# sys指系统相关的，比如python的运行路径，库的路径
os.path.abspath(".")
sys.path.append("..")
sys.path
#函数调用参数
sys.argv
 
常用的内建模块
 
# 日志模块
import logging
logging.basicConfig(format='%(asctime)s %(filename)s %(levelname)s %(message)s',level=logging.INFO)
logger = logging.getLogger(__name__)
logger.info("测试日志")
 
# requests 模块 参考url：https://www.liaoxuefeng.com/wiki/1016959663602400/1183249464292448
import requests
url = "http://baidu.com"
response = requests.get(url)
#返回体 response，返回体一般都是属性，返回函数的情况较少
print(response.url)
print(response.status_code)
print(response.headers)
print(response.content)
 
# 跟数值计算相关、数组相关的基本可以使用这个库
#参考url：https://blog.caiyongji.com/2020/12/06/pre-ml-numpy-3.html
import numpy as np
test_list = [1,2,3,4]
test_array = np.array(test_list)
test_array.sort()
array_reshape = test_array.reshape((2,2))
 
# pandas DataFrame使用：https://blog.csdn.net/weixin_38168620/article/details/79580312
# df []行通过切片访问，列通过 列名（单个或列表），比如df[0:3] df[['id','name']],df[0:3]['name']
# df.loc [][] 必须出现行列，第一个[]为行 第二个[]为列,可以切片，可以列表
import pandas as pd 
test_list = {"name":["a","b","c"],"id":["1","2","3"],"age":[3,4,5]}
df = pd.DataFrame(test_list)
#dataframe访问
#下标访问
df[0:2] 
df['name']
df[['name','id']]
#行列一起访问,
df[0:1][['name','id']]
#下标访问同时可以用来过滤数据
df[df['id']>'2']
# .loc 和 .iloc .at  .iat访问
# 带i表示使用索引，没i则是使用标签值取获取，行列使用逗号，同时支持使用切片
# df.iloc[[0,2],0:3]
#loc列支持切片访问，[]是不支持列的切片访问的
# df.loc[0:3,'name':'id']
df.columns
#df.index
# iterrows(): 按行遍历，将DataFrame的每一行迭代为(index, Series)对，可以通过row[name]对元素进行访问。
# itertuples(): 按行遍历，将DataFrame的每一行迭代为元祖，可以通过row[name]对元素进行访问，比iterrows()效率高。
# iteritems():按列遍历，将DataFrame的每一列迭代为(列名, Series)对，可以通过row[index]对元素进行访问。
#遍历 行
# for index,series in df.iterrows():
#     print(index)
#     print(series)
# for column,item in df.iteritems():
#     print(column)
#     print(type(item))
for one in df.itertuples():
    print(one.age)
 
python collections模块使用
 
#collections
#defaultdict:可以提供默认值返回
#OrderDict：记住插入顺序
#Counter：用于计数，也是一个dict
#nametuple：有点像定义一个类型
#deque：插入比list更快,同时支持下标访问
from collections import defaultdict,deque,namedtuple,OrderedDict,Counter
default_dict = defaultdict()
default_dict.get("test_key","default value")
counter = Counter()
counter['test_key']
Point = namedtuple("Point",['x', 'y'])
point = Point(1,2)
deque = deque()
deque.append('a')
deque.appendleft('b')
deque.append('c')
deque.pop()
deque.popleft()
 
                    目录注释和引号使用、编码数据类型和变量lambda、zip、map、reduce、enumerate函数注释和引号使用、编码# encoding=utf-8 或者 # -*- utf-8 -*-单行注释：#多行注释：''' '''或者""" """字符串：单引号：'' 双引号：" " 三引号：''' ''' 或""" """,三引号支持换行转义：r'',r不转义字符串数据类型和变量整数（int）、浮点数（float）、复数（complex）、字符串（str)、
rootPath = os.path.abspath(__file__)
rootPath = (rootPath.rsplit('/', 1)[0]).rsplit('/', 1)[0]
但是Pycharm警告说,
进程可以简单的理解为一个可以独立运行的程序单位，它是线程的集合，进程就是有一个或多个线程构成的。而线程是进程中的实际运行单位，是操作系统进行运算调度的最小单位。可理解为线程是进程中的一个最小运行单元。
二、Python代码实现
在Python3中可以利用 threading 模块创建多线程，每实例化一次即创建一次线程。
import _thread
import time
# 为线程定...
				
C++2.0中引入了tuple类型，该类型的引入，该类型的引入使得开发人员不需要定义结构体，就可以在一个对象中存储不同的数据类型，极大的方便了代码编写，举例代码如下：
void TestTuple()
 tuple<int, int, float, string> tp(1, 2, 3.1, "全世界");
 cout << "第一个元素为:" << get<0>(tp) << endl;
 cout <<...
				
因为python跟java在数据类型转换方面语法不同，所以总是搞混，特此记录下来，方便查阅：
在python中：
字符串str转换成int: int_value = int(str_value)
int转换成字符串str: str_value = str(int_value)
int -> unicode: unicode(int_value)
unicode -> int: int(u