python study note_python 应为类型 'list[tuple[int, int, str]] | none',但实

参考教程

目录

注释和引号使用、编码

数据类型和变量

lambda、zip、map、reduce、enumerate函数

_xx、__xxx、__xxx__的区别

类、函数定义、异常处理

IO编程

os和sys模块

常用的内建模块

注释和引号使用、编码、*和**的区别

# encoding=utf-8 或者 # -*- utf-8 -*-

单行注释：#

多行注释：''' '''或者""" """

字符串：单引号：'' 双引号：" " 三引号：''' ''' 或""" """,三引号支持换行

转义：r'',r不转义字符串

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):
        try:
            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()

IO编程

文件读写

file_name = "test.txt"
try:
    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()
try:      
    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()