pandas介绍pandas 是 Python 的核心数据分析支持库，提供了快速、灵活、明确的数据结构，旨在简单、直观地处理关系型、标记型数据。基本数据结构Series 和 DataFrame是pandas的两个核心数据结构，分别代表着一维的序列和二维的表结构。基于这两种数据结构，Pandas 可以对数据进行导入、清洗、处理、统计和输出。Series类似于字典结构，由索引和值构成index:values,默认索引是int类型，从0开始。# 导入模块 import pandas as pd # 使用Series构造方法 data = pd.Series([1,2,3,4,5]) print(data)Series类型数据创建一个类似字典和列表的数据对象。s = pd.Series(data,index=index,name=None) 参数： data:数据 index,索引，默认是int，从0开始 name,别名创建1.通过列表创建list1 = ['apple','pear','banana','peach'] data = pd.Series(list1) print(data) # 输出 0 apple 1 pear 2 banana 3 peach dtype: object # 也可以手动指定索引,可以是列表等迭代对象，需要注意与值对应，否则会报错 list1 = ['apple','pear','banana','peach'] data = pd.Series(list1,index=['First','Second','Third','Fourth']) print(data)2.通过字典创建字典是key-value形式，会自动将索引录入index作为索引。info = {'name':'chuck','age':25,'sex':'男','height':'165cm'} data = pd.Series(info) print(data) # 输出 name chuck age 25 sex 男 height 165cm dtype: object3.通过numpy的数组创建还没学，以后再补上。查看索引或者值# 直接输出Series对象 print(data) # 输出 name chuck age 25 sex 男 height 165cm weight 55kg Name: test, dtype: object # 查看所有索引 print(data.index) # 输出 Index(['name', 'age', 'sex', 'height', 'weight'], dtype='object') # 查看所有的值 print(data.values) # 输出 ['chuck' 25 '男' '165cm' '55kg'] # 通过指定的索引查看对应的值，可以通过下标或者索引名称 print(data['weight']) print(data[0]) print(data[1:3]) # 输出 55kg chuck添加和修改# 直接通过键值对赋值添加 data['wage'] = '9500' print(data['wage']) # 输出 9500常用属性和方法values属性返回一个数组，可以进行切片截取操作。info = {'name':'chuck','age':25,'sex':'男','height':'165cm'} data = pd.Series(info,name='test') val = data.values for i in val: print(i) # 输出 chuck 25 男 165cm # 切片 print(val[0:2])index属性获取索引，返回一个数组系列。info = {'name':'chuck','age':25,'sex':'男','height':'165cm'} data = pd.Series(info,name='test') indexs = data.index for i in indexs: print(i) # 输出 name age sex heightdtype属性，返回基础数据的类型。print(data.dtype)size属性，返回基础数据元素的数量。print(data.size)hasnans属性，如果数据有Nan,则返回True,否则返回Falseprint(data.hasnans)name属性，给Series索引命名。data = pd.Series(info,name='test') print(data.name)loc/iloc属性访问指定的值print(data.loc['height']) print(data.iloc[3])head()、tail()方法返回前几行和后几行数据print(data.head(2)) print(data.tail(2)) # 输出 name chuck age 25 Name: test, dtype: object sex height 165cm Name: test, dtype: object统计类方法，主要针对数值。sum,求和 mean,求平均值 max,最大值 min,最小值 count，计数 median,求中位数 describe,返回一个所有描述信息的Series对象 unique,统计去重之后的数量 nunique,所有数量 isnull,是否null,是为true,否为false sort_index,对索引排序,ascending控制升序或降序，使用True和False,kind选择算法，na_position空值的位置，默认为last sort_values,对数值排序DataFrameDataFrame对象是一种表格型的数据结构，包含行索引、列索引以及一组数据。# 格式 pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=None) data 表示输入的数据，可以是 ndarray，series，list，dict，标量以及一个 DataFrame。 index 表示行标签，如果没有传递 index 值，则默认行标签是 RangeIndex(0, 1, 2, …, n)，n 代表 data 的元素个数。 columns 表示列标签，如果没有传递 columns 值，则默认列标签是 RangeIndex(0, 1, 2, …, n)。 dtype 表示要强制的数据类型。只允许使用一种数据类型。如果没有定义强制的数据类型，就会自行推断。 copy 表示从输入复制数据。对于 dict 数据，copy=True，表示重新复制一份。对于 DataFrame 或 ndarray 输入，类似于 copy=False，在原数据中进行操作。创建可以从列表和字典# 从列表创建 data = [1,2,3,4,5] df = pd.DataFrame(data) print(df) # output 0 0 1 1 2 2 3 3 4 4 5 从Series对象创建s = pd.Series(['apple','pear','peach','strawberry']) data1 = pd.DataFrame(s,columns=['水果']) print(data1) # output 水果 0 apple 1 pear 2 peach 3 strawberry从嵌套列表创建，每个元素作为一列list1 = [['chuck',25],['joan',26]] data2 = pd.DataFrame(list1,columns=['姓名','年龄']) print(data2) #output 姓名 年龄 0 chuck 25 1 joan 26从字典创建,一个键值对作为一列，值的数量要对应dict1 = {'姓名':['chuck','joan','ley','cheny'],'性别':['男','女','男','女'],'年龄':[25,26,25,26]} data3 = pd.DataFrame(dict1) print(data3) # output 姓名 性别 年龄 0 chuck 男 25 1 joan 女 26 2 ley 男 25 3 cheny 女 26添加数据1.通过直接赋值方式添加新列。dict1 = {'姓名':['chuck','joan','ley','cheny'],'性别':['男','女','男','女'],'年龄':[25,26,25,26]} data3 = pd.DataFrame(dict1) data3['工作城市']=pd.Series(['深圳','揭阳','广州','茂名']) print(data3) # output 姓名 性别 年龄 工作城市 0 chuck 男 25 深圳 1 joan 女 26 揭阳 2 ley 男 25 广州 3 cheny 女 26 茂名2.使用insert()添加df.insert(loc, column, value, allow_duplicates=False) #loc,列的下标0,表示第一列，1第二列 # column列名 # value值,可以是列表多个值，如果是单个值就是列的值为相同 data2.insert(loc=2,column='性别',value=['男','女']) data2.insert(loc=3,column='城市',value='深圳') # 输出 姓名 年龄 性别 城市 0 chuck 25 男 深圳 1 joan 26 女 深圳修改data2.rename(columns={'姓名':'name','城市':'工作地址'},inplace=True) # rename() # columns为修改的列，column= {old:new},inplace=True表示修改原有data2,否则返回一个新的DataFrame对象 # 修改新的data3从原有data2 data3 = data2.rename(columns={'姓名':'name','城市':'工作地址'}) print(data3)删除使用drop删除DataFrame.drop(labels=None,axis=0, index=None, columns=None, inplace=False) labels：要删除的行或列，用列表给出 axis：默认为0，指要删除的是行，删除列时需指定axis为1 index ：直接指定要删除的行，删除多行可以使用列表作为参数 columns：直接指定要删除的列，删除多列可以使用列表作为参数 inplace: 默认为False，该删除操作不改变原数据；inplace = True时，改变原数据 # 示例 # 删除一行 # data2.drop(index=0,inplace=True) data2.drop(columns=1,inplace=True) print(data2)常用方法read_excel()从表格导入数据。pandas.read_excel( io, sheet_name=0, header=0, names=None, index_col=None, usecols=None, squeeze=False, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skiprows=None, nrows=None, na_values=None, keep_default_na=True, verbose=False, parse_dates=False, date_parser=None, thousands=None, comment=None, skipfooter=0, convert_float=True, mangle_dupe_cols=True, **kwds) # 常用属性 id,读取的文件名 sheet_name,读取的sheet表，默认为0 header,表头首行，默认0，如果从第一行开始0行会忽略，None表示不使用源数据的表头 names,自定义表头，传递列表 index_col,指定列为索引，默认为None,就是索引为0的列作为索引，可以设置源数据表中相关字段为索引 usecols,读取指定列，默认为None,读取所有列，可以使用字符串指定列名或者通过'A','B','C'指定列，'A:E' squeeze，默认为False,读取一列返回Series对象，设置为True不返回dtype dtype,数据类型，默认None,不改变数据类型 engine，可以指定使用第三方库处理excel文件，如xlrd,openpyxl converters,对指定列应用方法函数，可以是def或者lambda函数 true_values、alse_values将指定文本转换为True或者False skiprows,指定跳过的行，int类型 nrows，用于大量数据读取，读取前几行，int类型。 na_values，指定某些列的某些值为NaN。 keep_default_na，表示导入数据时是否导入空值。默认为True，即自动识别空值并导入 # 示例 import pandas as pd import numpy as np df = pd.read_excel('通讯录.xlsx',nrows=10,usecols='B:I') # print(df) # 删除编号 # print(df.loc[:,['姓名','性别']]) print(df)导出数据方式：to_csv()path_or_buf：要写入的文件或文件对象的字符串路径。如果是文件对象，则必须使用newline='' sep：输出文件的字段分隔符（默认“，”） na_rep：缺失值的字符串表示形式（默认为“”） float_format：浮点数的格式字符串 columns：要写入的列（默认为无） header：是否写出列名（默认为 True） index：是否写入行（索引）名（默认为 True） index_label：如果需要，索引列的列标签。如果无 （默认值），且为 True，则索引名称为 使用。（如果使用多索引，则应给出一个序列）。headerindexDataFrame mode：Python 写入模式，默认为“w” encoding：一个字符串，表示在内容为 非 ASCII，适用于 3 之前的 Python 版本 lineterminator：表示行尾的字符序列（默认os.linesep) quoting：设置报价规则，如在 csv 模块中（默认 csv.QUOTE_MINIMAL）。请注意，如果您设置了 那么浮点数将转换为字符串和 csv。QUOTE_NONNUMERIC会将它们视为非数字float_format quotechar：用于引用字段的字符（默认为“”） doublequote：控制 in 字段的引用（默认值为 True）quotechar escapechar：用于转义的角色和转义时间 适当（默认无）sepquotechar chunksize：一次要写入的行数 date_format：日期时间对象的格式字符串to_excel()df.to_excel("path_to_file.xlsx", sheet_name="Sheet1") # 指定文件名和表名 # 将多个df写入一个表中 with pd.ExcelWriter("path_to_file.xlsx") as writer: df1.to_excel(writer, sheet_name="Sheet1") df2.to_excel(writer, sheet_name="Sheet2")to_dict()df.to-dict( orient='dict' into= None) 函数中只需填一个参数：orient即可，但对于写入的orient不同，字典的构造方式也不同，其中有一种是列表形式 orient = 'dict' 函数默认，转换后的字典形式：{column:{index:value}} orient = 'list'转换后字典形式：{column:[values]} orient = 'series'转换后字典形式：{column:Series(value)} orient = 'split'转换后字典形式：{'index':[index],'columns':[columns],'data':[values]} orient = 'records'转换后list形式：[{column:value}...{column:value}] orient = 'index'转换后字典形式：{index:{column:value}}loc()方法获取指定行或列。# pandas 的 .loc() 方法是一个用于选择行和列的函数，它可以帮助你在 pandas 数据帧中定位和选择特定的数据。使用方法是在数据帧名称后面跟上 .loc[]，然后在方括号内输入行和列的标签，标签可以是整数、字符串或布尔值。 # 格式 df.loc[行标签,列标签] data = pd.DataFrame(np.arange(25).reshape(5,5),index=list('abcde'),columns=list('ABCDE')) # 提取指定行 print(data.loc['a']) # output A 0 B 1 C 2 D 3 E 4 Name: a, dtype: int32 # 提取多行，需要将行标签用列表写明，列标签可以省略或者使用:表示所有列 print(data.loc[['a','d'],:]) # output A B C D E a 0 1 2 3 4 d 15 16 17 18 19 # 提取指定行的指定列 print(data.loc[['a','d'],['A','B','D']]) # output A B D a 0 1 3 d 15 16 18 # 指定行的条件查询获取，查询A列的值大于10，并且B列值大于20的行 print(data.loc[(data['A'] > 10) & (data['B'] > 20)]) # output A B C D E e 20 21 22 23 24 # 通过loc进行赋值操作 data.loc['a','A'] = 99iloc()通过下标获取指定行和列,iloc索引器用于按位置进行基于整数位置的索引或者选择。data = pd.DataFrame(np.arange(25).reshape(5,5),index=list('abcde'),columns=list('ABCDE')) # 格式：df.iloc [row selection, column selection] # 查询第一行数据，和loc类似，通过下标从0开始可以使用:或者-1等 print(data.iloc[0,:]) # output A 0 B 1 C 2 D 3 E 4 Name: a, dtype: int32 # 获取多行 print(data.iloc[[0,2],:]) # output A B C D E a 0 1 2 3 4 c 10 11 12 13 14 dropna()删除空值。pandas.DataFrame.dropna(self, axis=0, how='any', thresh=None, subset=None, inplace=False) # 参数说明 axis：默认为 0，表示逢空值剔除整行，如果设置参数 axis＝1 表示逢空值去掉整列。 how：默认为 'any' 如果一行（或一列）里任何一个数据有出现 NA 就去掉整行，如果设置 how='all' 一行（或列）都是 NA 才去掉这整行。 thresh：设置需要多少非空值的数据才可以保留下来的。 subset：设置想要检查的列。如果是多个列，可以使用列名的 list 作为参数。 inplace：如果设置 True，将计算得到的值直接覆盖之前的值并返回 None，修改的是源数据。replace()替换方法。df.replace(to_replace=None,value=None,inplace=False,limit=None,regex=False,method='pad) # 参数 to_replace 查找要替换的值 value 替换与查找匹配的值 inplace 修改原数据(True/False) limit 向前或向后填充的最大尺寸间隙 regex 是否支持正则表达式(True/False) method 替换方法 # 示例 data.replace(0, '未知', inplace=True) # output A B C D E a 未知 1 2 3 4 b 5 6 7 8 9 c 10 11 12 13 14 d 15 16 17 18 19 e 20 21 22 23 24rename()重命名行列索引。DataFrame.rename(self, mapper=None, index=None, columns=None, axis=None, copy=True, inplace=False, level=None, errors='ignore') # 参数 mapper,字典或者映射，默认是修改行index索引 index行索引，以字典形式，赋予索引新的值 { 0 : “第一行”} columns，以字典形式，赋予列名新的值 { A : “第一列”} axis指定坐标轴 “index” or “columns” inplace,是否修改源数据对象 errors，针对错误的处理，ignore为忽略，raise为报错。 # 示例 data.rename(columns={'A':'姓名','B':'性别','C':'年龄','D':'身高','E':'体重'},inplace=True) data.rename(index={'a':0,'b':1,'c':2,'d':3,'e':4},inplace=True) print(data) # output A B C D E a 0 1 2 3 4 b 5 6 7 8 9 c 10 11 12 13 14 d 15 16 17 18 19 e 20 21 22 23 24 姓名 性别 年龄 身高 体重 0 0 1 2 3 4 1 5 6 7 8 9 2 10 11 12 13 14 3 15 16 17 18 19 4 20 21 22 23 24drop_duplicates()去除重复项。DataFrame.drop_duplicates(subset=None, keep='first', inplace=False) # 参数 subset,用来指定特定的列，默认所有列 keep, {'first','last', False}, default 'first' inplace,是否修改源对象。 # 示例 data = pd.read_excel('test.xlsx') print('初始数据：\n',data) data.drop_duplicates(inplace=True) print('去重后数据：\n',data) # output 初始数据： 工号 姓名 年龄 入职日期 性别 部门 岗位 0 1.0 张三 26 2019-10-07 男 信息管理中心 网络工程师 1 NaN joan 27 2019-07-01 女 业务部 业务员 2 NaN chuck 26 NaT NaN NaN NaN 3 1.0 张三 26 2019-10-07 男 信息管理中心 网络工程师 4 NaN chuck 26 2023-05-19 男 信息部 工程师 去重后数据： 工号 姓名 年龄 入职日期 性别 部门 岗位 0 1.0 张三 26 2019-10-07 男 信息管理中心 网络工程师 1 NaN joan 27 2019-07-01 女 业务部 业务员 2 NaN chuck 26 NaT NaN NaN NaN 4 NaN chuck 26 2023-05-19 男 信息部 工程师 # 指定subset参数，只有姓名和年龄列重复就删除 data.drop_duplicates(inplace=True,subset=['姓名','年龄'])astype()修改数据类型，默认每一列都是一个Series对象，有dtype属性。(dtype: Any | _str | Type[str] | Type[bytes] | Type[date] | Type[datetime] | Type[timedelta] | Type[bool] | Type[int] | Type[float] | Type[complex] | Type[Timestamp] | Type[Timedelta], copy: _bool = ..., errors: IgnoreRaise = ...) -> Series data['工号'].astype('str') print(data.info()) # 输出 <class 'pandas.core.frame.DataFrame'> Int64Index: 3 entries, 0 to 2 Data columns (total 7 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 工号 1 non-null object 1 姓名 3 non-null object 2 年龄 3 non-null int64 3 入职日期 2 non-null datetime64[ns] 4 性别 2 non-null object 5 部门 2 non-null object 6 岗位 2 non-null object dtypes: datetime64[ns](1), int64(1), object(5) memory usage: 132.0+ bytes Nonefillna()填补空值。print(data.fillna('Miss',inplace=True))
neimikoPython基于CLI模式与网络设备进行交互的工具包有很多，而netmiko与paramiko无疑是这类工具包中的两颗璀璨明珠。它是工程师Kirk Byers 于2015年发布的一个用于简化众多厂商网络设备CLI连接（ssh、telnet、serial）的工具类。实际2015年的版本只支持ssh，所以它最早是为了简化ssh通用工具类paramiko的连接和操作（后续netmiko已经支持了telnet和serial），所以它的名字从中取了"miko"，又因其垂直于网络自动化领域，所以又添加了“net”，组成了netmiko的名称。neimiko基本满足了对主流网络设备的支持，可以辅以paramiko和telnlib的功能实现复杂的需求。安装pip install netmiko支持的平台huawei(华为)hp_comware(华三)fortinet(飞塔)cisco_asa(思科ASA)cisco_ios(思科交换机)Ruijie Networks(锐捷)Arubajuniper创建连接网络运维对设备管理的第一步就是登录设备，可以使用netmiko的函数ConnectHandlerfrom netmiko import ConnectHandlerConnectHandler实例化参数包括设备类型，设备地址，账号密码等信息。返回一个长连接字典对象。示例：conn = ConnectHandler(device_type='hp_comware', host='192.168.128.208', username='admin', password='WZS134125', port=22) print(conn) '''以上输出一个实际的连接对象 <netmiko.cisco.cisco_ios.CiscoIosSSH object at 0x000002DBC9F23F10> ''' conn.disconnect()常用的参数：说明参数名ip设备IP地址host设备host名称，需要可以解析出IP地址username用户名password密码secretenable密码，提权时需要输入的密码port端口，会根据device_type自动判断（如有“ssh”字符串是22，如有“telnet”是23）可以用户指定device_type设备的驱动名称conn_timeout连接超时时间，默认为5秒，如果网络条件不好，建议适当增加，尤其是广域网或者国际网络timeout执行命令的超时时间，根据情况适当延长，默认为100秒session_log记录log的路径，如填写则会将与设备的所有操作记录session_log_file_mode记录log的模式，覆盖"write" ，追加 "append"，默认覆盖global_delay_factor默认的全局的延迟因子，值为1，但是一般不修改。fast_cli快速模式，默认False，不开启，netmiko内部提供一种优化性能的方式，设置为True后，在与设备交互过程中读取隧道中信息的频率会加快（全局延迟因子与单个方法中的延迟因子取较小值）。命令执行netmiko的很多入门也以show命令演示为主，主要用到了netmiko的send_command方法与send_commnad_timing方法,都用于发送单条display/show命令。send_command方法# 官方文档 # https://ktbyers.github.io/netmiko/docs/netmiko/index.html#netmiko.BaseConnection.send_command def send_command (self, command_string: str, expect_string: Optional[str] = None, read_timeout: float = 10.0, delay_factor: Optional[float] = None, max_loops: Optional[int] = None, auto_find_prompt: bool = True, strip_prompt: bool = True, strip_command: bool = True, normalize: bool = True, use_textfsm: bool = False, textfsm_template: Optional[str] = None, use_ttp: bool = False, ttp_template: Optional[str] = None, use_genie: bool = False, cmd_verify: bool = True) ‑> Union[str, List[Any], Dict[str, Any]]常用参数：command_string：要在远程设备上执行的命令。expect_string：用于确定输出结束的正则表达式模式。 如果留空，则默认基于路由器提示。read_timeout：等待寻找模式的最长时间。将提高读取超时 如果超过超时，适用于需要读取大量信息或者时间较长的操作防止程序终止,默认10秒。auto_find_prompt：使用 find_prompt（） 覆盖基本提示符。strip_prompt：从输出中删除尾随路由器提示符（默认值：True）。strip_command：从输出中删除命令的回显（默认值：True）。normalize：确保在命令末尾发送正确的输入（默认值：True）cmd_verify：在继续操作之前验证命令回显（默认值：True）。一般情况下只需要调整前面3个参数即可。示例：# 模块导入 from netmiko import ConnectHandler # 交换机自动备份配置 # 设备信息 device = {'device_type':'hp_comware', 'ip':'192.168.128.208', 'username':'admin', 'password':'2z6d*EZ1cf', 'session_log' : 'swback.log' } # 创建连接 conn = ConnectHandler(**device) # 执行命令，将回显写入output output = conn.send_command(command_string='dis ip int b') print(output) # 输出 Interface Physical Protocol IP address VPN instance Description Vlan2 up up -- -- MGT Vlan3 up up -- -- -- Vlan4 up up -- -- ҵ Vlan128 up up 192.168.128.208 -- MGT Vlan129 up up -- -- MJ Vlan132 up up -- -- --示例2：# 模块导入 from netmiko import ConnectHandler # 交换机自动备份配置 # 设备信息 device = {'device_type':'hp_comware', 'ip':'192.168.128.208', 'username':'admin', 'password':'2z6d*EZ1cf', 'session_log' : 'swback.log' } conn = ConnectHandler(**device) output = conn.send_command(command_string='dis cur',read_timeout=15) print(output)send_commnad是基于回显匹配来判断命令是否执行完成，可以自动或者通过正则表达式匹配。send_commnad_timing方法使用基于延迟的机制在 SSH 通道上执行command_string。一般 用于显示命令，意思是不基于判断回显判断命令是否完成而是基于时间因子，过了一定时间后继续执行剩下的任务。send_command_timing (self, command_string: str, last_read: float = 2.0, read_timeout: float = 120.0, delay_factor: Optional[float] = None, max_loops: Optional[int] = None, strip_prompt: bool = True, strip_command: bool = True, normalize: bool = True, use_textfsm: bool = False, textfsm_template: Optional[str] = None, use_ttp: bool = False, ttp_template: Optional[str] = None, use_genie: bool = False, cmd_verify: bool = False) ‑> Union[str, List[Any], Dict[str, Any]]常用参数与send_command方法类似。command_string：要在远程设备上执行的命令。last_read：数据结束后等待的时间,默认2秒。read_timeout：Netmiko 应该继续读取数据多长时间的绝对计时器 通道（等待没有新数据）。如果出现这种情况，将引发读取超时 超时过期。read_timeout值为 0 将导致读取循环永不超时 （即Netmiko将无限期地继续阅读，直到没有新数据和last_read 传输），默认120秒。示例1：# 模块导入 from netmiko import ConnectHandler # 交换机自动备份配置 # 设备信息 device = {'device_type':'hp_comware', 'ip':'192.168.128.208', 'username':'admin', 'password':'2z6d*EZ1cf', 'session_log' : 'swback.log' } conn = ConnectHandler(**device) output = conn.send_command_string(command_string='dis cur',last_read=1) print(output) send_config_set通过 SSH 通道按顺序发送配置命令,config_commands 是一个包含所有配置命令的可迭代对象(列表、元组等),命令将一个接一个地执行，自动退出/进入配置模式，适用于设备配置(不涉及show、save等)# 参数 send_config_set (self, config_commands: Union[str, Sequence[str], Iterator[str], TextIO, ForwardRef(None)] = None, *, exit_config_mode: bool = True, read_timeout: Optional[float] = None, delay_factor: Optional[float] = None, max_loops: Optional[int] = None, strip_prompt: bool = False, strip_command: bool = False, config_mode_command: Optional[str] = None, cmd_verify: bool = True, enter_config_mode: bool = True, error_pattern: str = '', terminator: str = '#', bypass_commands: Optional[str] = None) ‑> str # 示例，自动进入配置模式执行commands中的命令,通过参数控制配置完成是否退出配置模式 # 模块导入 from netmiko import ConnectHandler # 交换机自动备份配置 # 设备信息 device = {'device_type':'hp_comware', 'ip':'192.168.128.208', 'username':'admin', 'password':'2z6d*EZ1cf', 'session_log' : 'swback.log' } conn = ConnectHandler(**device) commands = ['int vlan 2','ip add 192.168.50.1 24','desc test'] output = conn.send_config_set(config_commands=commands,exit_config_mode=True) print(output) # 输出 system-view System View: return to User View with Ctrl+Z. [KL_HC_JT_SW_208]int vlan 2 [KL_HC_JT_SW_208-Vlan-interface2]ip add 192.168.50.1 24 [KL_HC_JT_SW_208-Vlan-interface2]desc test [KL_HC_JT_SW_208-Vlan-interface2]return <KL_HC_JT_SW_208>常用参数：config_commands：要发送到设备的多个配置命令。exit_config_mode：确定完成后是否退出配置模式。(True/False)read_timeout：发送到read_channel_timing的绝对计时器。还调整 read_timeout read_until_pattern通话。config_mode_command：进入配置模式的命令,华为华三是system-view,思科是enable,自动，一般不需要修改。strip_prompt：确定是否去除提示，一般不修改即可。strip_command：确定是否剥离命令，一般不修改即可。cmd_verify：是否验证config_set中每个命令的命令回显，默认即可。enter_config_mode：在发送配置命令之前是否进入配置模式，默认即可。error_pattern：用于检测输出，默认即可。一般前面4个即可，其他默认，可以实现多个命令顺序执行的情况。send_config_from_file方法send_config_set方法的扩展，从文件沿 SSH 通道发送配置命令，文件逐行处理，每个命令都向下发送 SSH 通道,可以实现从文件读取操作命令执行。# 参数 def send_config_from_file (self, config_file: Union[str, bytes, ForwardRef('PathLike[Any]')], **kwargs: Any) ‑> str # 示例 # 模块导入 from netmiko import ConnectHandler # 交换机自动备份配置 # 设备信息 device = {'device_type':'hp_comware', 'ip':'192.168.128.208', 'username':'admin', 'password':'2z6d*EZ1cf', 'session_log' : 'swback.log' } conn = ConnectHandler(**device) command = 'int vlan 2 \nip add 192.168.50.1 24\ndesc test\ndis ip int b\n' with open('command.txt',mode='w',encoding='utf-8') as f: f.write(command) commands_file = 'command.txt' output = conn.send_config_from_file(config_file=commands_file) print(output) # 输出 Interface Physical Protocol IP address VPN instance Description Vlan2 up up 192.168.50.1 -- test Vlan3 up up -- -- -- Vlan4 up up -- -- ҵ Vlan128 up up 192.168.128.208 -- MGT Vlan129 up up -- -- MJ Vlan132 up up -- -- --常用参数：config_file：要发送到设备的配置文件的路径kwargs：要发送到send_config_set方法的参数其他功能函数find_prompt()方法，可以获取设备回显名称。print(conn.find_prompt())config_mode()进入配置模式conn.config_mode()save_config()方法，保存设备配置，通过识别设备类型，自动进入配置模式，进行配置保存。conn.save_config()示例：import time from netmiko import ConnectHandler import pandas as pd def get_batch_backup_dev_infos(file='sw_list.xlsx'): df = pd.read_excel(file) items = df.to_dict(orient='records') dev_infos = [] for i in items: dev = i dev_infos.append(dev) return dev_infos devices = get_batch_backup_dev_infos() for device in devices: # 创建连接 connect = ConnectHandler(**device) # 执行配置保存 connect.save_config() # 文件命名 hostname = device['host'] +'-'+connect.find_prompt().strip('[]') now = time.strftime('%Y%m%d',time.localtime()) file_name = '/backup/'+hostname+'-'+now +'.cfg' # 通过从命令列表循环执行 commands = ['return','ftp 192.168.80.2','wuzeshu','WZS134125','ascii',"put startup.cfg "+file_name,'bye','quit'] for command in commands: connect.send_command_timing(command) print(hostname + '备份任务已完成！') print('所有备份已经完成！')
Easygui模块的使用安装pip3 install easygui常用函数easygui是一个Python模块，用于创建图形用户界面(GUI)。它提供了多种对话框、输入框、选择框等界面元素，使得Python编程更加友好和直观。下面是一些常用的easygui函数和模块：查看示例：easygui.egdemo()msgboxeasygui.msgbox(msg, title=' ', ok_button='OK', image=None, root=None)：创建一个消息框，显示消息msg，并带有一个“OK”按钮。可选的参数包括对话框的标题title、按钮的文本ok_button、图像image和root窗口对象。一种用于显示简单信息的对话框，通常用于显示提示信息、警告信息或错误信息等。它的常用参数如下：msg：要显示的信息内容，可以是字符串、数字等。 title：对话框的标题。 ok_button：指定显示的按钮文本，默认为“OK”。 image：指定显示的图标，默认为None。可以使用easygui提供的图标（如"tiger.gif"）或者指定自定义的图标路径。 msgbox对话框只有一个确定按钮，用于用户确认所显示的信息。它的返回值是一个字符串，表示用户按下的按钮文本。 示例： import easygui as e e.msgbox(msg="打开一个消息窗口",title="游戏开始",image="C:\\Users\\Administrator\\Pictures\\Camera Roll\\33.gif")buttonboxeasygui.buttonbox(msg, title=' ', choices=('Button1', 'Button2', 'Button3'), image=None, root=None)： # 示例 import easygui as e user_choice = e.buttonbox(msg="请选择对应选项",title="游戏初始化",choices=("开始游戏","退出游戏"))创建一个按钮框，显示消息msg，并带有一组按钮，返回被点击的按钮的文本。可选的参数包括对话框的标题title、按钮的文本choices、图像image和root窗口对象。choiceboxeasygui.choicebox(msg, title=' ', choices=('Choice1', 'Choice2', 'Choice3'), preselect=0, image=None, root=None)：创建一个选择框，显示消息msg，并带有一组选项，返回被选中的选项的文本。可选的参数包括对话框的标题title、选项的文本choices、默认选中的选项preselect、图像image和root窗口对象。enterboxeasygui.enterbox(msg, title=' ', default='', strip=True, image=None, root=None)：创建一个文本输入框，显示消息msg，并返回用户输入的字符串。可选的参数包括对话框的标题title、默认字符串default、是否去掉字符串两端的空格strip、图像image和root窗口对象。ynboxeasygui.ynbox(msg, title=' ', choices=('Yes', 'No'), image=None, default_choice='Yes', cancel_choice='No', root=None)：创建一个包含“是”和“否”两个按钮的确认框，显示消息msg，并返回True或False。可选的参数包括对话框的标题title、按钮的文本choices、默认选中的按钮default_choice、取消按钮的文本cancel_choice、图像image和root窗口对象。multenterboxeasygui.multenterbox(msg, title=' ', fields=[], values=[], text_color='black', background_color='white', show=True, image=None, root=None)：创建一个多行文本输入框，显示消息msg，并返回用户输入的字符串列表。可选的参数包括对话框的标题title、输入框的名称列表fields、默认值列表values、文本颜色text_color、背景颜色background_color、是否显示输入框名称show、图像image和root窗口对象。fileopenboxeasygui.fileopenbox(msg=None, title=None, default='*', filetypes=None, multiple=False)：创建一个文件打开对话框，用于选择文件。ccboxccbox是easygui中的一个函数，用于显示一个带有“确认”和“取消”按钮的对话框，并返回用户单击的按钮。其函数原型如下：ccbox(msg="Shall I continue?", title=" ", choices=("Continue", "Cancel"), image=None) # 参数说明： msg：要显示的消息字符串。 title：对话框的标题。 choices：一个包含两个字符串的元组，分别代表确认和取消按钮的文本。默认为("Continue", "Cancel")。 image：可选参数，用于指定在对话框中显示的图像文件名。 ccbox函数返回一个布尔值，代表用户单击的按钮。如果用户单击了“确认”按钮，则返回True，否则返回False。
循环Python中的循环语句包括for循环和while循环，它们都可以用来遍历序列或执行重复操作。下面是一些循环的基本用法：for循环for循环用于遍历序列（字符串、列表、元组等）中的每个元素，也可以使用range函数来生成一个整数序列进行遍历。# for循环格式： for 变量 in 序列: 循环体语句 # 遍历序列 fruits = ['apple', 'banana', 'cherry'] for fruit in fruits: print(fruit) # 遍历整数序列 for i in range(1, 5): print(i) while循环while循环用于在条件满足的情况下重复执行一段代码块，需要注意可能导致死循环，需要设置跳出循环的条件。# while循环格式，条件表达式为True时执行循环体 while 条件: 循环体语句 # while循环 count = 0 while count < 5: print(count) count += 1在循环中，还可以使用break和continue语句进行控制：break语句可以立即跳出循环；continue语句可以跳过当前循环，继续执行下一次循环。# break语句 fruits = ['apple', 'banana', 'cherry'] for fruit in fruits: if fruit == 'banana': break print(fruit) continue语句fruits = ['apple', 'banana', 'cherry'] for fruit in fruits: if fruit == 'banana': continue print(fruit)循环语句还可以和else语句一起使用，当循环正常执行完毕时，else语句会被执行。for循环中的else语句fruits = ['apple', 'banana', 'cherry'] for fruit in fruits: print(fruit) else: print('No more fruits') while循环中的else语句count = 0 while count < 5: print(count) count += 1 else: print('count >= 5')以上就是Python中循环语句的基本用法，可以根据实际需要灵活使用。分支语句if-else语句if语句是Python中的一种分支语句，用于在满足某个条件时执行一段代码块，否则执行另一段代码块。if语句的基本语法格式如下：if 条件: 代码块1 else: 代码块2条件是一个表达式，如果表达式的值为True，则执行代码块1；否则执行代码块2。代码块1和代码块2可以是任意数量的语句块，缩进的语句块是属于相应代码块的。if-elif-else语句if-elif-else语句是Python中的一种分支语句，用于在多个条件中选择一个分支执行代码块。if-elif-else语句的基本语法格式如下：if 条件1: 代码块1 elif 条件2: 代码块2 elif 条件3: 代码块3 ... else: 代码块nif-elif-else语句判断输入的整数num是正数、负数还是零。如果num大于0，则执行代码块1，打印输出num是正数；否则，判断elif后面的条件2，如果num小于0，则执行代码块2，打印输出num是负数；否则，执行else后面的代码块3，打印输出num是零。在使用if-elif-else语句时，需要注意各个条件的设置和代码块的缩进。
模块模块是一个包含 Python 代码的文件，可以在其他 Python 程序中被引用和调用。模块使得代码可以更好地组织和复用，避免了重复编写相同的代码。一个 Python 模块通常包含变量、函数和类等各种代码块，这些代码块可以在其他 Python 程序中被引用和使用。使用 import 语句可以将一个模块引入到当前程序中，并使用其中的代码。Python 模块可以是标准库模块、第三方库模块或自定义模块等，它们可以用于完成各种任务，如数学计算、网络编程、文件处理、数据可视化等。常用的标准库模块有 os、sys、re、math 等，常用的第三方库模块有 numpy、pandas、matplotlib 等，用户也可以根据自己的需要编写自定义模块。在 Python 中，模块可以是一个单独的 .py 文件，也可以是一个包含多个 .py 文件的目录。如果一个目录中包含一个名为 __init__.py 的文件，那么该目录就可以作为一个 Python 包来使用。通过将模块组织成包的方式，可以更好地组织代码，并且可以避免模块命名冲突的问题。os模块os 模块是 Python 标准库中的一个模块，提供了一系列与操作系统交互的函数和方法，可以用来管理文件和目录、处理进程和环境变量等。下面介绍一些 os 模块的常用函数和方法：os.name：返回当前操作系统的名称，Windows 下为 'nt'，Linux/Unix 下为 'posix'。os.getcwd()：返回当前工作目录的绝对路径。os.chdir(path)：将当前工作目录改变为指定路径。os.listdir(path)：返回指定目录下的所有文件和目录名。os.mkdir(path)：创建一个新目录。os.makedirs(path)：递归地创建多级目录。os.rmdir(path)：删除指定目录，只能删除空目录。os.removedirs(path)：递归地删除多级目录，如果中间某个目录非空则无法删除。os.path.abspath(path)：返回指定路径的绝对路径。os.path.exists(path)：判断指定路径是否存在。os.path.isdir(path)：判断指定路径是否为目录。os.path.isfile(path)：判断指定路径是否为文件。以上函数和方法只是 os 模块中的一部分，还有许多其他函数和方法可以用来处理文件、进程、环境变量等。在使用 os 模块时需要注意，一些操作需要具有相应的权限才能执行，否则会出现权限错误。getcwd()获取当前工作目录的绝对路径import os # 输出当前工作目录的路径 print(os.getcwd())chdir(path)改变工作目录import os # 输出当前工作目录的路径 print(os.getcwd()) # 切换工作路径 os.chdir("./python基础") # 再输出当前工作路径 print(os.getcwd())listdir(path='.')列出指定目录下的文件结构import os # 输出当前目录下的文件和文件夹，不能递归列出子目录下文件 print(os.listdir())mkdir(path)创建目录import os # 查看当前目录 print(os.getcwd()) # 创建目录 os.mkdir("测试目录") # 列出当前文件夹下的文件和目录 print(os.listdir("."))makedirs(path)创建多层目录import os # 查看当前目录 print(os.getcwd()) # 创建目录 os.makedirs("测试目录\\a\\b")remove(path)删除文件import os # 使用相对路径 os.remove("abc.txt") # 使用绝对路径 os.remove("E:\\Files\\python\\sw.log")rmdir(path)删除单层目录import os # 只能删除一层目录，多层目录会报错 os.rmdir("E:\Files\python\测试目录\\a\\b")removedirs(path)递归删除多层目录import os # 删除多层目录 os.removedirs("测试目录/a")rename(old,new)重命名文件或目录import os # 就目录为测试目录，重命名为C os.rename("测试目录","C") # 重命名文件，需要注意路径是否正确，否则可能报错文件不存在 with open("C\\abc.txt","wt",encoding="utf-8") as f: f.write("这是一个测试文件") os.rename("C\\abc.txt","C\\A.txt")system(command)执行系统命令# python通过os模块，执行系统命令 import os # 执行打开任务管理器命令 os.system("taskmgr") # 执行打开控制面板命令 os.system("control")walk(top)遍历目录结构import os # 通过os.walk(top)返回一个三元组，通过for循环遍历输出 for i in os.walk("C"): print(i) # 输出格式为：(路径,包含目录,包含文件) ('C', ['a', 'D'], ['A.txt']) ('C\\a', ['b'], []) ('C\\a\\b', [], []) ('C\\D', [], [])其他os.curdir()表示当前目录os.pardir()表示上一级目录os.name()表示当前使用的操作系统os.path模块常用函数与方法函数名使用方法basename(path)去掉目录路径，单独返回文件名dirname(path)去掉文件名，返回目录路径join(path1[.path2])将path1和path2各部分注册一个路径名split(path)分割文件名和路径，返回(f)path,f_name)元组splitext(path)分离文件名与扩展名，返回(f.name,f_extension)元组getsize(file)返回文件的尺寸，单位是字节getatime(file)返回指定文件的访问时间，浮点型秒数，可以使用time进行转换getctime(file)返回指定文件的创建时间getmtime(file)返回指定文件的最新的修改时间exists(path)判断指定目录或文件是否存在，返回True或Falseisbas(path)判断指定路径是否为绝对路径iSdir(path)判断指定路径是否存在且是一个目录isfile(path)判断是否存在一个文件islink(path)判断是否是一个符号链接ismount(path)判断是否是一个挂载点samefile(path1,path2)判断是否指向同一个文件
打开文件使用open()函数打开文件，具体参数为：open(file, mode='r', buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)参数解析：1、file：必须指定，表示要打开的文件名或文件路径。文件名可以是一个字符串类型的文件名，也可以是一个文件描述符（例如在 Unix/Linux 中，可以使用类似 os.open() 的函数获取文件描述符）。2、mode：用于指定打开文件的模式，有如下几种：模式用法'r'只读模式。打开文件后只能读取文件内容，不能进行写入操作。如果文件不存在，则抛出异常。'w'写入模式。打开文件后只能进行写入操作，如果文件不存在则创建文件。如果文件已经存在，则覆盖文件内容。'a'追加模式。打开文件后只能进行写入操作，如果文件不存在则创建文件。如果文件已经存在，则在文件末尾追加新的内容。'x'独占写入模式。打开文件后只能进行写入操作，如果文件已经存在则抛出异常。'b'二进制模式。打开文件后读写的是二进制数据而不是文本数据。这种模式常用于处理非文本文件，例如图像、音频、视频等。't'文本模式。打开文件后读写的是文本数据。这种模式是默认模式。'+'读写模式。打开文件后既可以进行读取操作也可以进行写入操作。如果文件不存在则创建文件。这些模式可以组合使用，例如 'rb' 表示以二进制模式打开文件，并进行读取操作。另外需要注意的是，mode 参数还可以在模式后面加上 t 或者 b 来指定文件的文本模式或者二进制模式。例如，'rt' 表示以文本模式打开文件进行读取操作，'wb' 表示以二进制模式打开文件进行写入操作。如果不指定 t 或 b，则默认为文本模式3、buffering：表示缓冲区大小，用于控制读写操作时数据的缓存策略。有如下几种取值：0：表示不进行缓存，所有数据都直接写入或读取。1：表示使用行缓存，数据会先缓存到内存中，直到读取到一行完整的数据后再一次性写入或读取。大于1的整数：表示使用指定大小的缓存区，缓存区的大小就是这个整数。负数：表示使用默认缓存大小，具体大小与系统有关。4、encoding：表示文件的编码方式，例如 'utf-8'、'gbk' 等。如果不指定该参数，则使用系统默认编码。encoding 参数是 Python 中 open() 函数的可选参数之一，它用于指定文件的编码格式。在文本模式下打开文件时，如果不指定 encoding 参数，则默认使用操作系统的默认编码格式。如果要读写的文本文件使用的编码格式与操作系统的默认编码格式不同，那么就需要通过 encoding 参数指定正确的编码格式。例如，如果要读写一个使用 UTF-8 编码的文本文件，就需要在打开文件时指定 encoding='utf-8'。常用的编码格式有：utf-8：一种常用的 Unicode 编码格式，适用于多种语言。gbk：一种中文编码格式，适用于简体中文操作系统。gb2312：一种早期的中文编码格式，适用于简体中文操作系统。big5：一种繁体中文编码格式，适用于繁体中文操作系统。在打开文件时指定正确的编码格式可以确保程序正确地读取和写入文件内容。如果没有正确地指定编码格式，则可能会导致文件内容乱码或者读取失败的问题。5、errors：用于控制在编码或解码时出现错误的处理方式。有如下几种取值：'strict'：默认值，表示遇到错误时抛出异常。'ignore'：表示遇到错误时忽略错误。'replace'：表示用 '?' 来替代无法编码或解码的字符。'backslashreplace'：表示用 Python 的反斜杠转义序列代替编码错误的字符。'namereplace'：用 Unicode 编码的字符名代替编码错误的字符。open()函数具有返回值，为一个文件对象。示例：f = open("abc.txt") # f就是这个返回值，针对文件对象可以进行相应的操作。文件对象的方法：read(size=-1)：从文件中读取数据，并返回一个字符串。如果指定了 size 参数，则读取指定大小的数据，否则读取整个文件。readline(size=-1)：从文件中读取一行数据，并返回一个字符串。如果指定了 size 参数，则读取指定大小的数据，否则读取一行数据。readlines(hint=-1)：从文件中读取所有行，并返回一个字符串列表。如果指定了 hint 参数，则读取指定大小的数据，否则读取所有行。write(string)：向文件中写入一个字符串。writelines(sequence)：向文件中写入一个字符串序列，序列中的每个字符串都会被写入文件。close()：关闭文件，释放文件资源。seek(offset[, whence])：将文件指针移动到指定位置。offset 参数指定要移动的字节数，whence 参数指定移动的起始位置，可选值为 0（文件开头）、1（当前位置）、2（文件末尾）。tell()：返回文件指针当前的位置。flush()：将缓冲区的数据写入文件。需要注意的是，在使用完文件后，一定要调用 close() 方法关闭文件，否则可能会出现文件被锁定无法使用的情况。如果使用 with 语句打开文件，则不需要手动调用 close() 方法，with 语句会自动关闭文件。文件的写入：# 写入一个abc.txt文件，模式为文本模式x写入，编码格式为utf-6 file = open("abc.txt",mode='xt+',encoding='utf-8') # 调用write()方法，写入文本字符串 file.write("encoding：表示文件的编码方式，例如\n"\ "'utf-8'、'gbk' 等。如果不指定该参数，则使用系统默认编码.\n"\ "encoding 参数是 Python 中 open() 函数的可选参数之一，\n"\ "它用于指定文件的编码格式。在文本模式下打开文件时，\n"\ "如果不指定 encoding 参数，则默认使用操作系统的默认编码格式。\n") # 调用close()关闭正确文件 file.close()文件的读取：# 将open()函数的返回值赋值给f，使用read()方法 f = open("abc.txt","r",encoding="utf-8") # 将读取的内容赋值给content content = f.read() # 将输出内容打印 print(content) # 关闭文件 f.close()逐行读取文件：# 将open()函数的返回值赋值给f，使用read()方法 f = open("abc.txt","r",encoding="utf-8") # 将读取的内容赋值给content,每次输出一行 content = f.readline() # 将输出内容打印 print(content) # 关闭文件 f.close()文件的关闭：对文件对象调用close()方法正确关闭文件。使用with语句自动关闭文件：# 使用with语句，将返回值赋值给f with open("abc.txt","r",encoding="utf-8") as f: f.seek(20,0) # 读取每一行输出赋值给line line = f.readline() # 通过while循环判断是否为真 while line: # 输出 print(line.lstrip()) # 将下一行继续执行赋值 line = f.readline()文件的读取和定位：使用seek()和tell()方法进行定位。# 使用tell()方法输出现在指针的位置 with open("sw.log","r",encoding="utf-8") as f: print("现在的文件位置为:" + str(f.tell())) line = f.readline() print(line) print("现在的文件位置为:" + str(f.tell())) with open("sw.log","r",encoding="utf-8") as f: # seek(偏移的字节，从哪个位置开始，0表示开头，1表示当前位置，2代表末尾) f.seek(20,0) print("现在的文件位置为:" + str(f.tell())) line = f.readline() print(line) print("现在的文件位置为:" + str(f.tell()))
python字典Python字典是一种无序、可变、键-值对的集合。每个键值对都由一个键和一个值组成，键值对之间用逗号分隔，整个字典用大括号包围。字典的键必须是唯一的，而值可以是任何数据类型，包括数字、字符串、列表、元组、甚至是字典。以下是一个简单的Python字典的例子：# 创建一个字典 my_dict = {"apple": 2, "banana": 3, "orange": 4} # 输出字典 print(my_dict) # 输出结果： {'apple': 2, 'banana': 3, 'orange': 4}在上面的例子中，我们创建了一个包含3个键值对的字典，并将其存储在变量my_dict中。我们可以通过调用print()函数来输出这个字典。Python字典支持许多常用的操作，包括添加、更新、删除、查询等等字典的创建1、使用大括号 {} 和冒号 : 创建字典，每个键值对之间用逗号 , 分隔。例如：person = {'name': 'Tom', 'age': 25, 'city': 'Beijing'}2、使用 dict() 函数创建字典，每个键值对之间用逗号 , 分隔。例如：person = dict(name='Tom', age=25, city='Beijing')3、使用键列表和值列表来创建字典，可以使用 zip() 函数将键列表和值列表打包成一个元组的列表，然后再使用 dict() 函数将其转换成字典。例如：Copy code keys = ['name', 'age', 'city'] values = ['Tom', 25, 'Beijing'] person = dict(zip(keys, values))其中，keys 列表中的元素为字典的键，values 列表中的元素为字典的值。zip() 函数将两个列表中的元素一一对应打包成元组，返回一个元组的列表，然后再使用 dict() 函数将其转换成字典。4、使用 fromkeys() 方法创建字典，fromkeys() 方法使用指定的键列表作为字典的键，将它们的值设置为默认值。例如：keys = ['name', 'age', 'city'] person = dict.fromkeys(keys, 'unknown')上面代码中，将 keys 列表作为字典的键，将它们的值都设置为 'unknown'。注意：字典中的键必须是可哈希的，即不可变类型，如字符串、整数、浮点数、元组等。常用方法fromkeys()方法fromkeys()是字典类的一个方法，用于创建一个新字典，其中给定的键（或迭代器）具有一个默认值。它的语法如下：dict.fromkeys(keys[, value])其中，keys是一个包含要用作字典键的值的序列或可迭代对象，value是可选参数，指定要用作默认值的值。如果不提供value参数，则默认为None。以下是一些示例：# 从列表创建字典 keys = ['a', 'b', 'c'] new_dict = dict.fromkeys(keys) print(new_dict) # {'a': None, 'b': None, 'c': None} # 从元组创建字典 keys = ('x', 'y', 'z') new_dict = dict.fromkeys(keys, 0) print(new_dict) # {'x': 0, 'y': 0, 'z': 0} # 从集合创建字典 keys = {'mango', 'banana', 'apple'} new_dict = dict.fromkeys(keys, 1) print(new_dict) # {'apple': 1, 'banana': 1, 'mango': 1}在第一个示例中，keys是一个包含字典键的列表。由于未提供value参数，因此将使用默认值None。调用dict.fromkeys()方法将返回一个新字典，其中所有键都将设置为None。在第二个示例中，keys是一个包含字典键的元组，并且为value参数提供了默认值0。在这种情况下，调用dict.fromkeys()方法将返回一个新字典，其中所有键都将设置为0。在第三个示例中，keys是一个包含字典键的集合，并且为value参数提供了默认值1。在这种情况下，调用dict.fromkeys()方法将返回一个新字典，其中所有键都将设置为1。keys()方法keys() 方法返回一个字典视图对象，该对象包含字典中所有的键。字典视图对象是一个动态对象，它会随着字典内容的更改而更新。例如：my_dict = {'name': 'Alice', 'age': 25, 'gender': 'female'} keys = my_dict.keys() print(keys) # dict_keys(['name', 'age', 'gender']) # 修改字典内容 my_dict['phone'] = '123456789' print(keys) # dict_keys(['name', 'age', 'gender', 'phone'])注意：在 Python 2.x 中，keys() 方法返回一个列表，而不是字典视图对象。values()方法values() 方法是 Python 字典（dictionary）类型的内置方法，用于获取字典中的所有值。该方法返回一个包含字典所有值的列表。以下是一个示例：person = {'name': 'Alice', 'age': 30, 'city': 'New York'} values = person.values() print(values)输出结果为：dict_values(['Alice', 30, 'New York'])可以看到，values() 方法返回了一个列表，其中包含了字典中的所有值。在上面的示例中，这些值分别为 'Alice'、30 和 'New York'。需要注意的是，返回的列表中的元素顺序是不确定的，并且可能与添加键值对的顺序不同。如果要按照特定顺序获取值，可以先使用 keys() 方法获取键列表，然后根据键列表中的顺序来获取值。person = {'name': 'Alice', 'age': 30, 'city': 'New York'} keys = ['name', 'age', 'city'] values = [person[key] for key in keys] print(values)输出结果为：['Alice', 30, 'New York']在这个示例中，我们首先使用 keys() 方法获取了字典中所有的键，然后使用列表推导式遍历键列表，根据键来获取对应的值，并将这些值存储在一个新的列表中。这样就可以按照特定顺序获取值了。items()方法items() 方法是 Python 字典（dictionary）类型的内置方法，用于返回字典的所有 (key, value) 元组。语法格式如下：dict.items()其中，dict 表示字典名称。该方法返回的结果是一个可迭代对象，其中每个元素都是一个 (key, value) 元组，其中 key 表示字典中的键，value 表示对应的值。示例代码：Copy code d = {'apple': 1, 'banana': 2, 'orange': 3} items = d.items() print(items)输出结果：dict_items([('apple', 1), ('banana', 2), ('orange', 3)])可以使用 for 循环遍历 items 中的元素：for item in items: print(item)输出结果：('apple', 1) ('banana', 2) ('orange', 3)也可以通过转换为列表，再进行遍历：items_list = list(d.items()) print(items_list)输出结果：[('apple', 1), ('banana', 2), ('orange', 3)]注意，items() 方法返回的对象是一个视图（view）对象，该对象会随着原字典的修改而修改。因此，如果你在遍历字典的同时修改了字典，可能会导致错误的结果。get()方法get()方法用于获取字典中指定键的值，如果键不存在，可以指定默认值。其语法为：dict.get(key, default=None)其中，key表示要获取值的键，default表示当键不存在时返回的默认值，如果不指定默认值，则返回None。举个例子：person = {'name': 'Alice', 'age': 30, 'city': 'New York'} name = person.get('name') gender = person.get('gender', 'Unknown') print(name) # 输出 Alice print(gender) # 输出 Unknown，因为 gender 键不存在，使用了默认值clear()方法clear()方法是Python字典中的一个内置方法，用于清空字典中所有的元素。语法格式如下：dict.clear()其中，dict表示待清空的字典对象。例如：# 创建一个字典 my_dict = {'name': 'Tom', 'age': 25, 'gender': 'male'} # 清空字典 my_dict.clear() # 输出清空后的字典 print(my_dict) # 输出 {}copy()方法copy()方法是字典对象的一个方法，用于创建并返回一个字典的浅复制，即复制原字典的键值对，但是并不复制键和值本身。使用方法如下：original_dict = {"a": 1, "b": 2, "c": 3} new_dict = original_dict.copy()在上述代码中，original_dict是原始字典对象，new_dict是original_dict的浅复制。修改new_dict不会影响original_dict。需要注意的是，如果原始字典中的值本身是可变对象（比如列表），那么在浅复制中，复制后的新字典和原始字典中的这个值将引用同一个对象，因此修改一个字典的值也会影响到另一个字典的值。示例如下：original_dict = {"a": [1, 2], "b": 2} new_dict = original_dict.copy() new_dict["a"].append(3) print(original_dict) # 输出 {"a": [1, 2, 3], "b": 2} print(new_dict) # 输出 {"a": [1, 2, 3], "b": 2}在上面的示例中，原始字典original_dict包含一个值为列表的键值对{"a": [1, 2]}，使用copy()方法复制字典后，新字典new_dict也包含一个值为列表的键值对{"a": [1, 2]}。然后修改新字典new_dict中的列表值，即在列表末尾添加元素3，发现原始字典original_dict的对应值也发生了相应变化，即列表变为[1, 2, 3]。update()方法update()方法是字典对象的一个方法，它用于将一个字典中的键值对更新到另一个字典中。如果存在相同的键，那么会用新的值覆盖旧的值。该方法有两种不同的用法：传递一个字典作为参数，将该字典中的键值对更新到原字典中：dict1 = {'name': 'Alice', 'age': 20} dict2 = {'age': 21, 'city': 'Beijing'} dict1.update(dict2) print(dict1) # 输出 {'name': 'Alice', 'age': 21, 'city': 'Beijing'}传递键值对作为参数，将它们添加到原字典中，如果键已经存在，则更新对应的值：dict1 = {'name': 'Alice', 'age': 20} dict1.update(age=21, city='Beijing') print(dict1) # 输出 {'name': 'Alice', 'age': 21, 'city': 'Beijing'}需要注意的是，如果传递了不合法的参数，比如传递了多个值给一个键，则会抛出TypeError异常。另外，update()方法并不返回任何值，它直接修改原字典对象。
python元组元组（tuple）是一个有序的不可变序列，可以包含任意类型的数据，包括数值、字符串、列表、元组等。元组与列表非常相似，但是元组不可变，意味着一旦创建就不能修改，而列表是可变的。元组使用小括号 () 定义，多个元素之间使用逗号 , 分隔。例如：my_tuple = (1, 2, 'a', 'b', [3, 4])元组也支持切片和索引操作，可以使用 len() 函数获取元组长度。另外，可以使用 in 关键字判断元素是否在元组中。元组的不可变特性意味着无法在原有元组中增加、删除或修改元素。不过可以通过连接两个或多个元组创建新的元组，也可以使用 tuple() 函数将其他序列（如列表）转换成元组。例如：tuple1 = (1, 2, 3) tuple2 = (4, 5, 6) new_tuple = tuple1 + tuple2 print(new_tuple) # 输出 (1, 2, 3, 4, 5, 6) my_list = [1, 2, 3] my_tuple = tuple(my_list) print(my_tuple) # 输出 (1, 2, 3)元组的创建Python中元组是一种有序、不可变的序列，可以用来存储多个数据。元组的创建有以下几种方法：1、直接使用小括号括起来的数据序列创建元组：my_tuple = (1, 2, 3, 4, 5)2、使用tuple()函数将其他序列转换为元组：my_list = [1, 2, 3, 4, 5] my_tuple = tuple(my_list)如果元组中只有一个元素，需要在元素后面加上一个逗号来区分元组和表达式中的括号：my_tuple = (1,)3、使用括号来创建空元组：my_tuple = ()无论哪种方法，都可以创建一个元组。元组中的元素可以是任何类型，包括其他元组，如：nested_tuple = ((1, 2), (3, 4), (5, 6))需要注意的是，元组是不可变的，因此不能添加、删除或修改元组中的元素。如果需要对元组中的数据进行修改，可以将元组转换为列表进行修改，然后再将列表转换回元组。更新元组通过转换成列表来更新元组元组是不可变的数据类型，所以无法直接更新元组中的元素。如果需要更新元组中的元素，需要先将元组转换成列表，然后在列表中更新元素，最后再将列表转换回元组。以下是一个更新元组中元素的例子：# 定义一个元组 t = (1, 2, 3, 4) # 将元组转换成列表 t_list = list(t) # 更新列表中的元素 t_list[2] = 5 # 将列表转换回元组 t = tuple(t_list) print(t) # 输出 (1, 2, 5, 4)在上面的例子中，我们先将元组 (1, 2, 3, 4) 转换成列表 t_list，然后更新列表中的第三个元素为 5，最后再将列表 t_list 转换回元组 t。通过多个元组来扩展更新元组的元素由于元组是不可变的，因此不能直接更新元组的元素。但是，可以通过创建一个新的元组来扩展和更新元组的元素。可以使用加号操作符来连接两个元组，从而创建一个新的元组。例如，假设有一个元组a = (1, 2, 3)，要在其末尾添加一个元素4，可以这样做：a = (1, 2, 3) b = a + (4,) print(b) # 输出 (1, 2, 3, 4)注意，添加新元素时需要使用逗号将其与原来的元组分隔开，以保持它们是元组类型而不是其他类型。删除可以使用del语句删除整个元组。
python函数一函数的基础定义Python是一门函数式编程语言，函数在Python中扮演着非常重要的角色。在Python中，函数可以接收输入参数并返回输出结果，可以作为参数传递给其他函数，也可以定义在类中作为方法。Python中定义函数的语法如下：def function_name(parameters): """函数文档字符串""" # 函数体 return expression其中，function_name为函数的名称，parameters是函数的输入参数列表，可以为空。函数体内的代码是实现函数功能的语句，可以包含一些控制流语句、变量定义、其他函数调用等等。函数可以返回一个表达式的值作为输出结果，也可以没有返回值。函数的定义可以包含文档字符串，用于描述函数的功能、输入输出参数、使用方法等等。文档字符串以三个引号（'''或"""）开头和结尾，位于函数定义的第一行。下面是一个简单的函数示例，实现对两个数进行求和的功能：def add(x, y): """将两个数相加并返回结果""" result = x + y return result在调用该函数时，可以传递两个数作为输入参数，获取返回结果：a = 2 b = 3 c = add(a, b) print(c) # 输出：5除了使用def语句定义函数外，Python还提供了lambda表达式用于定义匿名函数。lambda表达式的语法如下：lambda arguments: expression其中，arguments是函数的输入参数列表，expression是一个表达式，表示函数的输出结果。例如，下面的lambda表达式实现了对两个数相加的功能：add = lambda x, y: x + y c = add(2, 3) print(c) # 输出：5函数是Python中的重要概念，掌握函数的使用方法对于编写高质量的Python代码非常重要。函数的参数在 Python 函数中，形参是在定义函数时指定的参数，而实参是在调用函数时传递给函数的参数。形参是函数定义时使用的占位符，用来表示函数接收的参数。形参在函数调用时不占用内存空间，只有在函数调用时才会创建。实参是函数调用时传递给函数的参数。实参会占用内存空间，它们的值会传递给函数内部的形参，函数可以使用这些值来完成特定的任务。Python 中的参数传递方式有两种：位置参数和关键字参数。位置参数是按照参数定义的顺序进行传递，而关键字参数是按照参数名进行传递。同时，Python 还支持使用默认参数值和可变参数列表来扩展函数的功能。位置参数Python函数的位置参数是指在函数定义中，按照顺序声明的参数，调用函数时需要按照定义的顺序传入参数。例如，下面的函数中，a和b就是位置参数：Copy code def add_numbers(a, b): return a + b在调用函数时，需要按照定义的顺序传入参数：result = add_numbers(2, 3) print(result) # 输出 5在调用函数时，可以直接传入参数的值，也可以使用变量来传入参数的值：x = 4 y = 5 result = add_numbers(x, y) print(result) # 输出 9需要注意的是，调用函数时传入的参数数量必须与函数定义中参数数量一致，否则会抛出TypeError异常。关键字参数Python函数中的关键字参数是指通过指定形参名称来传递实参值的一种方式。关键字参数可以通过形参名称将值传递给函数，因此不需要按照特定的顺序传递参数。例如，下面的函数定义中包含了两个关键字参数：Copy code def greeting(name, message): print(f"{name}, {message}")使用关键字参数时，可以按照以下方式将实参传递给该函数：greeting(name="John", message="Hello")在这个例子中，我们将实参 "John" 通过关键字参数 name 传递给了 greeting() 函数，并将实参 "Hello" 通过关键字参数 message 传递给了函数。使用关键字参数时，参数的顺序并不重要，只要指定了形参名称，函数就能正确地获取对应的实参值。默认参数Python函数的默认参数是指在定义函数时，为函数的参数设置一个默认值。在函数调用时，如果没有为该参数传入实参，则使用默认值作为该参数的值。默认参数的定义方式为在函数定义时，在形参后面添加"="和默认值。例如：def greet(name, message="Hello"): print(message, name) greet("Alice") # 输出: Hello Alice greet("Bob", "Hi") # 输出: Hi Bob在上面的例子中，函数greet有两个参数，其中message参数有一个默认值"Hello"。在调用函数时，可以不传递message参数，这样会自动使用默认值；也可以传递一个新的值来覆盖默认值。可变参数Python函数的可变参数指的是可以接受任意数量参数的函数，包括位置参数、关键字参数或混合参数。在Python中，定义可变参数有两种方式：args：使用args，可以接收任意数量的位置参数，参数将以元组(tuple)的形式传入函数中。下面是一个使用*args的例子：def add(*args): sum = 0 for arg in args: sum += arg return sum print(add(1, 2, 3, 4, 5)) # 15 print(add(1, 2, 3)) # 6kwargs：使用kwargs，可以接收任意数量的关键字参数，参数将以字典(dict)的形式传入函数中。下面是一个使用**kwargs的例子：def print_info(**kwargs): for key, value in kwargs.items(): print(f'{key}: {value}') print_info(name='Tom', age=20, sex='male') # 输出： # name: Tom # age: 20 # sex: male可以使用args和kwargs组合来接受任意数量的参数，但是必须保证args参数在kwargs参数之前。下面是一个使用args和*kwargs的例子：def print_info(*args, **kwargs): for arg in args: print(arg) for key, value in kwargs.items(): print(f'{key}: {value}') print_info('Tom', 20, 'male', city='Beijing', school='Tsinghua University') # 输出： # Tom # 20 # male # city: Beijing # school: Tsinghua University这个函数可以接受任意数量的位置参数和关键字参数。总结：位置参数（Positional Arguments）：在函数定义时，根据参数位置来确定其意义和取值。关键字参数（Keyword Arguments）：在函数调用时，通过参数名来传递参数值，可以不按照参数位置顺序传递参数。默认参数（Default Arguments）：在函数定义时，为参数指定默认值，调用函数时，如果不传递该参数，则使用默认值。可变参数（Variable-length Arguments）：可变参数允许传递任意数量的参数，分为两种：args和kwargs。args用于传递任意数量的位置参数，kwargs用于传递任意数量的关键字参数。下面是一个函数参数类型的示例代码：# 位置参数 def func1(a, b, c): print(a, b, c) # 关键字参数 def func2(a, b, c): print(a, b, c) # 默认参数 def func3(a, b, c=0): print(a, b, c) # 可变位置参数 def func4(*args): for arg in args: print(arg) # 可变关键字参数 def func5(**kwargs): for key, value in kwargs.items(): print(key, value) # 调用函数 func1(1, 2, 3) # 输出：1 2 3 func2(c=3, a=1, b=2) # 输出：1 2 3 func3(1, 2) # 输出：1 2 0 func4(1, 2, 3) # 输出：1 2 3 func5(a=1, b=2, c=3) # 输出：a 1 b 2 c 3函数的返回值函数可以通过return语句返回值。return语句可以返回任何类型的数据，包括数字、字符串、列表、元组、字典、集合等等。如果函数没有指定返回值，则默认返回None。函数返回值的作用主要有以下两点：将计算结果返回给调用者，使其能够继续进行操作或者输出结果；在函数内部使用返回值进行逻辑判断，从而实现某些特定的功能。函数可以返回单个值，也可以返回多个值。如果返回多个值，则返回的值被封装在一个元组中，可以使用元组解包的方式获取其中的值。以下是一个返回单个值的函数的示例：def add(x, y): return x + y result = add(2, 3) print(result) # 输出：5以下是一个返回多个值的函数的示例：Copy code def get_user_info(user_id): # 从数据库中获取用户信息 name = "张三" age = 28 gender = "男" return name, age, gender name, age, gender = get_user_info(1001) print(name) # 输出：张三 print(age) # 输出：28 print(gender) # 输出：男需要注意的是，在函数内部使用return语句时，如果有多个return语句，则只会执行第一个return语句，后面的return语句不会被执行。如果函数没有return语句，则默认返回None。函数变量的作用域变量的作用域是指变量可以被访问的范围，可以分为全局作用域和局部作用域。全局作用域是指在程序的任何地方都可以访问的变量。在函数外定义的变量默认具有全局作用域，可以通过在函数内使用global关键字来在函数内部访问和修改全局变量。局部作用域是指在函数内部定义的变量，只能在函数内部访问。当函数执行结束后，局部变量会被销毁。在Python中，变量的作用域遵循LEGB规则，即：Local（局部）：函数内部的作用域Enclosing（嵌套）：嵌套函数内部的作用域Global（全局）：模块级别的作用域Built-in（内置）：Python内置函数的作用域在使用变量时，Python会按照LEGB的顺序查找变量。如果在当前作用域内找不到变量，则会向上一级作用域查找，直到找到该变量或者查找到全局作用域。如果还没有找到，则会引发NameError异常。