递归import osdef get_files(path):  # 判断路径是否存在,如果不存在，函数直接结束  if not os.path.exists(path):    print('路径不存在')    return  # 判断路径是否为文件夹  if not os.path.isdir(path):    print('路径是一个文件')    return  # 这时候，路径是一个文件夹  # 获取文件夹中文件或文件夹的名称  file_list = os.listdir(path)  # 遍历文件夹  for filename in file_list:    # 拼接路径，获取每个次级目录下的文件路径    subpath = os.path.join(path,filename)    if os.path.isfile(subpath):      if os.path.splitext(subpath)[1] == '.py':        print('python文件：{}'.format(subpath))    else:      # 如果filename是文件夹，则调用函数继续遍历      get_files(subpath) 用栈来遍历磁盘栈的特点：先进后厨，后进先出原理：path第一次被pop删除后返回path，遍历目录下的文件，如果遇到文件夹追加到列表中，pop是删除最后一位的元素，每次又遍历最后一位的文件夹，所以每一轮都会将次级目录下的文件夹遍历完成之后再遍历下个次级目录 import osdef get_files(path):  # 判断路径是否存在  if not os.path.exists(path):    print('路径不存在')    return  if not os.path.isdir(path):    print('路径是一个文件夹')    return  # 创建一个列表作为栈  stack = [path]  # 取出栈中的元素  while len(stack) != 0:    path = stack.pop()    file_list = os.listdir(path)    for filename in file_list:      subpath = os.path.join(path,filename)      if os.path.isfile(subpath):        print('python文件：{}'.format(subpath))      else:        stack.append(subpath) 广度遍历磁盘用队列遍历磁盘 import osimport collectionsdef get_py_file(path):  # 判断路径是否存在  if not os.path.exists(path):    print('路径不存在')    return    # 判断路径是否是文件夹  if os.path.isfile(path):    print('路径是文件')    return    # path是一个文件夹  # 定义一个空对列  queue = collections.deque()  queue.append(path)  while len(queue) != 0:    # 从队列中获取第一个元素    path = queue.popleft()    # 获取目录下的所有内容    filelist = os.listdir(path)    # 遍历    for filename in filelist:      # 拼接      filepath = os.path.join(path, filename)      if os.path.isfile(filepath):        if os.path.splitext(filepath)[1] == '.py':          print(filepath)      else:        queue.append(filepath)  

给你一个 32 位的有符号整数 x，返回将 x 中的数字部分反转后的结果。如果反转后整数超过 32 位的有符号整数的范围 [−2^31, 2^31 − 1] ，就返回 0。假设环境不允许存储 64 位整数（有符号或无符号）。示例 1：输入：x = 123输出：321示例 2：输入：x = -123输出：-321示例 3：输入：x = 120输出：21示例 4：输入：x = 0输出：0思路1：将其转为字符串进行翻转，并进行正负的判断。最后，题目要求如果反转后整数超过 32 位的有符号整数的范围 [−2^31, 2^31 − 1] ，就返回 0123456789class Solution:  def reverse(self, x: int) -> int:    str1 = str(x)         if str1[0] == '-':      str1 = str1[0] + str1[:0:-1]    else:      str1 = str1[::-1]    return int(str1) if -2147483648<int(str1)<2147483648 else 0思路2：不使用字符串。当翻转后的数字大于条件就返回01234567891011class Solution:  def reverse(self, x: int) -> int: y, res = abs(x), 0    # 则其数值范围为 [−2^31, 2^31 − 1]    boundry = (1<<31) -1 if x>0 else 1<<31    while y != 0:      res = res*10 +y%10      if res > boundry :        return 0      y //=10    return res if x >0 else -res改进：123456789101112131415class Solution:  def reverse(self, x: int) -> int:    str1 = str(x)         if str1[0] == '-':      str1 = str1[0] + str1[:0:-1]      a=int(str1)      if (1<<31)<abs(a):        return 0    else:      str1 = str1[::-1]      a= int(str1)      if a>(1<<31) -1:        return 0    return a 补充：问：说说Python反转三位整数有几种方法？答：这是leetcode上的一道编程算法题，感觉还是蛮经典的，今天就拿出来给大家分享一下！给出一个3位的正整数，你需要将这个整数中每位上的数字进行反转。例如：输入: 123，输出: 321 。大家先不看下面答案，看看如果是自己，可以想出几种Python方式来解决！下面分别来说说几种实现的方式:1、取余取整方式123456789class Test:  def reverseInteger(self, number):    g = number%10     #取出个位数    s = (int(number/10))%10  #取出十位数    b = int(number/100) #取出百位数    return g*100+s*10+bif __name__ == "__main__":  ts = Test()  print (ts.reverseInteger(123)) #输出结果：3212、使用栈的方式1234567891011class Test:  def reverseInteger(self, number):    number = str(number) # 模拟入栈    l = list(number)    result = ""    while len(l) > 0:      result += l.pop() # 模拟出栈    return int(result)if __name__ == "__main__":  ts = Test()  print (ts.reverseInteger(123)) # 输出结果：3213、使用切片的方式123456789class Test:  def reverseInteger(self, number):    number=str(number)    result=number[::-1] #python中切片的特殊用法    result=(int(result))    return resultif __name__ == "__main__":  ts = Test()  print (ts.reverseInteger(123))4、整数转字符串，反转字符串，然后再转整数1234567891011121314151617class Test:  def reverseInteger(self, x):    plus_minus = ""    reverse_x = ""    if x < 0:      plus_minus = "-"      x = -x    for i in str(x):      reverse_x = i + reverse_x    reverse_x = plus_minus + reverse_x    if int(reverse_x) > pow(2, 31) - 1 or int(reverse_x) < pow(-2, 31):      return 0    return int(reverse_x)  if __name__ == "__main__":  ts = Test()  print (ts.reverseInteger(123)) #输出结果：321

华为云博客地址：https://bbs.huaweicloud.com/blogs/254847 二叉树的递归思想很重要，还有递归的复杂度分析 - [1.1 二叉树的初始化](#11-二叉树的初始化) - [1.2 创建一个二叉树](#12-创建一个二叉树) - [1.3 前序遍历](#13-前序遍历) - [1.4 中序遍历](#14-中序遍历) - [1.5 后序遍历](#15-后序遍历) - [1.6 层序遍历](#16-层序遍历) - [1.7 计算节点数](#17-计算节点数) - [1.8 计算树的深度](#18-计算树的深度) - [1.9 计算树的叶子树](#19-计算树的叶子树) - [1.10 获取第K层节点数](#110-获取第k层节点数) - [1.11 判断两颗二叉树是否相同](#111-判断两颗二叉树是否相同) - [1.12 二叉树的镜像](#112-二叉树的镜像) - [1.13 找最低公共祖先节点](#113-找最低公共祖先节点) - [1.14 获取两个节点的距离](#114-获取两个节点的距离) - [1.15 找一个节点的所有祖宗节点](#115-找一个节点的所有祖宗节点) # 1.1 二叉树的初始化 ``` #initial of BinaryTree class BinaryTree: def __init__(self,rootObj): self.val = rootObj self.left = None self.right = None def insertLeft(self,newNode): if self.left == None: self.left = BinaryTree(newNode) else: t = BinaryTree(newNode) t.left = self.left self.left = t def insertRight(self,newNode): if self.right == None: self.right = BinaryTree(newNode) else: t = BinaryTree(newNode) t.right = self.right self.right = t ``` # 1.2 创建一个二叉树 ``` #create a BinaryTree [18,7,11,3,4,5,6,#,#,#,#,1,3,2,4] # 18 # 7 11 #3 4 5 6 # 1 3 2 4 root = BinaryTree(18) root.left = BinaryTree(7) root.right = BinaryTree(11) root.left.left = BinaryTree(3) root.left.right = BinaryTree(4) root.right.left = BinaryTree(5) root.right.right = BinaryTree(6) root.right.left.left = BinaryTree(1) root.right.left.right = BinaryTree(3) root.right.right.left = BinaryTree(2) root.right.right.right = BinaryTree(4) ``` # 1.3 前序遍历 ``` #递归版本 def PreOrder(self, node): if node: print(node.val) self.PreOrder(node.left) self.PreOrder(node.right) #循环版本 def PreOrderLoop(self, node): if node == None: return stack =[] print(node.val) stack.append(node) node = node.left while stack!=[] or node: while node: print(node.val) stack.append(node) node = node.left node = stack[-1].right stack.pop() #ouput: 18 7 3 4 11 5 1 3 6 2 4 ``` # 1.4 中序遍历 ``` #递归版本 def InOrder(self, node): if node: self.InOrder(node.left) print(node.val) self.InOrder(node.right) #循环版本 def InOrderLoop(self, node): if node == None: return None stack = [] stack.append(node) node = node.left while stack!=[] or node: while node: stack.append(node) node = node.left print(stack[-1].val) node = stack[-1].right stack.pop() #output：3 7 4 18 1 5 3 11 2 6 4 ``` # 1.5 后序遍历 ``` #递归 def PostOrder(self, node): if node: self.PostOrder(node.left) self.PostOrder(node.right) print(node.val) #非递归 def PostOrderLoop(self, node): if node == None: return stack =[] stack.append(node) pre = None while stack!=[]: node = stack[-1] if ((node.left==None and node.right==None) or (pre and (pre == node.left or pre ==node.right))): print(node.val) pre = node stack.pop() else: if node.right: stack.append(node.right) if node.left: stack.append(node.left) #output:3 4 7 1 3 5 2 4 6 11 18 ``` # 1.6 层序遍历 ``` def LevelOrder(self, node): if node == None: return stack = [] stack.append(node) while stack!=[]: node = stack[0] if node.left: stack.append(node.left) if node.right: stack.append(node.right) print(node.val) stack.pop(0) output: 18 7 11 3 4 5 6 1 3 2 4 ``` # 1.7 计算节点数 ``` #递归版本 def CountNode(self, root): if root == None: return 0 return self.CountNode(root.left) + self.CountNode(root.right) + 1 #非递归版本 def CountNodeNotRev(self, root): if root == None: return 0 stack = [] stack.append(root) index = 0 while index print(len(stack)) output: 11 ``` # 1.8 计算树的深度 ``` def getTreeDepth(self, root): if root == None: return 0 left = self.getTreeDepth(root.left) + 1 right = self.getTreeDepth(root.right) + 1 return left if left>right else right ``` # 1.9 计算树的叶子树 ``` def countLeaves(self, root): if root == None: return 0 if root.left==None and root.right==None: return 1 return self.countLeaves(root.left)+self.countLeaves(root.right) ``` # 1.10 获取第K层节点数 ``` def getKLevel(self, root, K): if root == None: return 0 if K == 1: return 1 return self.getKLevel(root.left, K-1)+self.getKLevel(root.right, K-1) ``` # 1.11 判断两颗二叉树是否相同 ``` def StrucCmp(self, root1, root2): if root1 == None and root2 == None: return True elif root1 ==None or root2 == None: return False return self.StrucCmp(root1.left, root2.left) and self.StrucCmp(root1.right, root2.right) ``` # 1.12 二叉树的镜像 ``` def Mirror(self, root): if root == None: return tmp = root.left root.left = root.right root.right = tmp self.Mirror(root.left) self.Mirror(root.right) ``` # 1.13 找最低公共祖先节点 ``` def findLCA(self, root, node1, node2): if root == None: return if root == node1 or root == node2: return root left = self.findLCA(root.left, node1, node2) right = self.findLCA(root.right, node1, node2) if left and right: return root return left if left else right ``` # 1.14 获取两个节点的距离 ``` def getDist(self, root, node1, node2): lca = self.findLCA(root, node1, node2) #找最低公共祖宗节点 level1 = self.FindLevel(lca, node1) #祖节点到两个节点的距离 level2 = self.FindLevel(lca, node2) return level1+level2 def FindLevel(self, node, target): if node == None: return -1 if node == target: return 0 level = self.FindLevel(node.left, target) if level == -1: level = self.FindLevel(node.right, target) if level != -1: return level + 1 return -1 ``` # 1.15 找一个节点的所有祖宗节点 ``` def findAllAncestor(self, root, target): if root == None: return False if root == target: return True if self.findAllAncestor(root.left, target) or self.findAllAncestor(root.right, target): print(root.val) return True return False ```

一. 查看DataFrame的常用属性DataFrame基础属性有：values(元素)、index(索引)、columns(列名) 、dtypes(类型)、size(元素个数)、ndim(维度数)和 shape(形状大小尺寸),还有使用T属性 进行转置import pandas as pddetail=pd.read_excel('E:\data\meal_order_detail.xlsx') #读取数据，使用read_excel 函数调用# print(detail)print("索引",detail.index)print("所以 值 ：",detail.values)print("所以列名：",detail.columns)print("数据类型：",detail.dtypes)print("元素个数：",detail.size)print("维度：",detail.ndim)print("形状大小 尺寸：",detail.shape)#使用T属性 进行转置print("转置前的形状：",detail.shape)数据print("转置后的形状：",detail.T.shape) 二. 查改增删DataFrame数据查看访问DataFramezhon'的数据（1.1）DataFrame数据的基本查看方式#使用字典访问方式order_id=detail['order_id']print("订单详情表的order_id的形状：",order_id.shape)#使用访问属性的方式 dishes_name=detail.dishes_nameprint("订单详情表中的dishes_name的形状：",dishes_name.shape)#DataFrame 单列多行的数据获取dishes_name5=detail['dishes_name'][:5]print(dishes_name5)#多列多行数据orderDish=detail[['order_id','dishes_name']][:5]print(orderDish)#访问多行数据order5=detail[:][1:6]print("订单详情表中的1~6行元素的数据：\n",order5) #使用DataFrame的head和tail方法获取多行数据print('订单详情表中前5行数据：\n',detail.head())#head()里面没有参数的话，默认为5行print('订单详情表中后5行数据：\n',detail.tail()) #tail()里面没有参数的话，默认为5行(1.2) .DataFrame的loc和iloc访问方式;dishes_name1=detail.loc[:,'dishes_name'] #DataFrame.loc[行索引名称或条件,列索引名称]print("使用loc提取dishes_name列的size：",dishes_name1.size)dishes_name2=detail.iloc[:,3] #DataFrame.iloc[行索引位置,列索引位置]print("使用iloc提取第3列的size：",dishes_name2.size) #使用loc、iloc 实现多列切片orderDish1=detail.loc[:,['order_id','dishes_name']]print(orderDish1.size)orderDish2=detail.iloc[:,[1,3]]print(orderDish2.size)#使用loc、iloc 实现花式切片print("列名为order_id和dishes_name 的行名为3的数据：\n",detail.loc[3,['order_id','dishes_name']])print('列名为order_id和dishes_name 行名为2、3、4、5、6的数据为：\n',detail.loc[2:6,['order_id','dishes_name']])print('列名1和3，行位置为3的数据为：\n',detail.iloc[3,[1,3]]) #这里为什么不可以loc函数，               #因为loc函数传入的是列索引的名称（或行的名称或条件），而iloc传入的是位置print('列位置为1和3，行位置为2，3，4，5，6的数据和：\n',detail.iloc[2:7,[1,3]])#这里是位置索引，7是取不到的#使用loc和iloc函数实现条件切片print('detail中order_id为458的dishes_name为：\n',detail.loc[detail['order_id']==458,['order_id','dishes_name']]) #使用了locprint("detail中order_id为458 的第1、5列的数据为：\n",detail.iloc[(detail['order_id']==458).values,[1,5]])#values 获取元素 #使用iloc函数(1.3).ix切片方法#使用loc、iloc、ix 实现切片 比较（DataFrame.ix[行的索引或位置或条件,列索引名称和位置]）print('列名为dishes_name行名为2，3，4，5，6的数据为：\n',detail.loc[2:6,['dishes_name']])print('列位置为5行名为2~6的数据为：\n',detail.iloc[2:6,5])print('列位置为5行名为2~6的数据为：\n',detail.ix[2:6,5])2.更改DataFame中的数据#将order_id为458 的改成 45800detail.loc[detail['order_id']==458,'order_id'] = 45800 #45800 这里 没有单引号的print('更改后detail中的order_id为 458 的：\n',detail.loc[detail['order_id']==458,'order_id'])print('更改后detail中的order_id为 45800 的：\n',detail.loc[detail['order_id']==45800,'order_id'])detail.loc[detail['order_id']==45800,'order_id'] = 4583.为DataFrame增添数据#新增一列非定值detail['payment']=detail['counts']*detail['amounts']print('detail新增列payment的前5行数据为：\n',detail['payment'].head())#新增一列定值detail['pay_way']='现金支付'print('detail新增列的前5行的数据为：\n',detail['pay_way'].head())``4.删除某行或某列的数据(drop)#删除某列print('删除pay_way前 detail中的列索引为：\n',detail.columns)detail.drop(labels='pay_way',axis=1,inplace=True)print('删除pay_way后 detail中的列索引为：\n',detail.columns)#删除某几行print('删除1~10行 前 detail的长度：',len(detail))detail.drop(labels=range(1,11),axis=0,inplace=True)print('删除1~10行 后 detail的长度：',len(detail)) 三. 描述分析DataFrame数据1.数值特征的描述性统计describe（）函数描述性统计2.类别类特征的描述性统计类型，categroy类型

这是一个不同食物(每100g)中不同营养成分的卡路里含量表格，表格为3行4列，列表示不同的食物种类，从左至右依次为苹果，牛肉，鸡蛋，土豆。行表示不同的营养成分，从上到下依次为碳水化合物，蛋白质，脂肪。那么，我们现在想要计算不同食物中不同营养成分中的卡路里百分比。现在计算苹果中的碳水化合物卡路里百分比含量，首先计算苹果（100g）中三种营养成分卡路里总和56+1.2+1.8 = 59，然后用56/59 = 94.9%算出结果。可以看出苹果中的卡路里大部分来自于碳水化合物，而牛肉则不同。对于其他食物，计算方法类似。首先，按列求和，计算每种食物中（100g）三种营养成分总和，然后分别用不用营养成分的卡路里数量除以总和，计算百分比。那么，能否不使用for循环完成这样的一个计算过程呢？假设上图的表格是一个4行3列的矩阵A，记为 A3X4，接下来我们要使用Python的numpy库完成这样的计算。我们打算使用两行代码完成，第一行代码对每一列进行求和，第二行代码分别计算每种食物每种营养成分的百分比。在jupyter notebook中输入如下代码，按shift+Enter运行，输出如下。面使用如下代码计算每列的和，可以看到输出是每种食物(100g)的卡路里总和。其中sum的参数axis=0表示求和运算按列执行。接下来计算百分比，这条指令将 的矩阵除以一个的矩阵，得到了一个 的结果矩阵，这个结果矩阵就是我们要求的百分比含量。下面再来解释一下A.sum(axis = 0)中的参数axis。axis用来指明将要进行的运算是沿着哪个轴执行，在numpy中，0轴是垂直的，也就是列，而1轴是水平的，也就是行。而第二个A/cal.reshape(1,4)指令则调用了numpy中的广播机制。

在数据预处理过程中可能需要将列的顺序颠倒，有两种方法。1234import numpy as npimport pandas as pddf = pd.DataFrame(np.array(range(20)).reshape(4,5))print(df)原始dataframe如下：12345  0  1  2  3  40  0  1  2  3  41  5  6  7  8  92 10 11 12 13 143 15 16 17 18 191. 方法一手动设置列名列表，应用在dataframe中（适合列名比较少的情况）我们可以手动来更换列的顺序123cols = [4,3,2,1,0]df = df.ix[:,cols]print(df)输出如下：12345  4  3  2  1  00  4  3  2  1  01  9  8  7  6  52 14 13 12 11 103 19 18 17 16 152. 方法二pandas提供颠倒列顺序的方式可以看出当数据的列较多时，方法一会非常繁琐，pandas提供一种非常简便的方式来进行列顺序的颠倒。12df = df.ix[:, ::-1]print(df)输出如下：12345  4  3  2  1  00  4  3  2  1  01  9  8  7  6  52 14 13 12 11 103 19 18 17 16 15补充：Python列表排序与倒序python学习笔记列表排序1、sort（）2、sorted()3、reverse()sort（）的使用123456letters = ['d','a','e','c','b']print letters['d','a','e','c','b']letters.sort()print letters['a','b','c','d','e']sort()会自动按照字母顺序对字符串由小到大排序，如果数字就由小到大注：sort（）会修改原来的列表他是修改列表，而不是创建新的列表。不应该1print letters.sort()而应该12letters.sort()print letters还可以用.sorted()函数12345678# 得到一个有序的副本列表#而不影响原来列表的顺序old = ['d','a','e','c','b']new = sorted(old)print old['d','a','e','c','b']print new['a','b','c','d','e']reverse的使用1234567891011# 方法1 作为reverse（）函数letters = ['d','a','e','c','b']letters.sort()print letters['a','b','c','d','e']letters.reverse()print letters['e','d','c','b','a']# 方法2 作为sort()函数参数letters = ['d','a','e','c','b']letter.sort(reverse = Ture)

1、编写注意（1）给函数指定描述名。（2）函数名称只包括小写字母和下划线。（3）每一个函数都应该包含简要说明其功能的注释，注释应该紧跟在函数定义之后，并且采用文档字符串格式。2、给形参指定默认值时，等号两侧不得有空格1def function_name(parameter_0, parameter_1='default value')3、如果程序或模块包含多个函数，可以使用两个空行将相邻函数分开，这样更容易知道前一个函数在哪里结束，下一个函数从哪里开始。1function_name(value_0, parameter_1='value')对于函数调用中的关键字实参，也应遵循所有import句子都应该放在文件开头。唯一的例外是，在文件开头使用注释来描述整个程序。知识点扩展：1.代码复用的第一步就是使用函数。2.一个函数可以接受任何数量（包括0）的任何类型的值最为输入变量，并且返回任何数（包括0）的任何类型的结果。3.Python中的一切都是对象，包括字符串、数字、元祖、列表、字典和函数。4.调用Python函数help()可以打印输出一个函数函数的参数列表和规范文档。如果仅仅是想要得到文档的字符串可以用doc。5.可以把函数作为函数的参数，函数也可以作为列表、元组、集合、和字典的元素。函数名是不可变得，因此可以把函数用作字典的键。Python的函数式一级对象，也就是说，我们可以直接引用函数把函数当成参数传给其他函数，并通过表达式及if语句对其进行比较和判断。6.闭包是一个可以由另一个函数动态生成的函数，并且可以改变和存储函数外创建的变量的值。（也可以说闭包是一个定义在某个作用域中的函数，这种函数引用了那个作用域里的变量。）7.Python使用特殊的规则来比较两个元组。它首先比较各元组中下标为0的对应元素。如果相等，再比较下标为1的对应元素，如果还是相等，那就继续比较下标为2的元素，一次类推。8.在表达式中引用变量时，Python解释器将会按照如下顺序遍历各作用域：9.给变量赋值时，规则有所不同。如果当前作用域内已经定义了这个变量，那么该变量就会具备新值。若是当前作用域内没有这个变量，Python则会把这次赋值视为对该变量的定义，而新定义的这个变量，其作用域就是包含赋值操作的这个函数。10.nonlocal语句。nonlocal清楚地表明如果在闭包中给该变量赋值，那么修改的其实是闭包外那个作用域的变量。但是，nonlocal的唯一限制是它不能延伸到模块级别，这个是为了防止它污染全局作用域。这个与global语句互补。global用来表示对该变量的赋值操作，将会直接修改作用域里的那个变量。11.考虑用生成器改写直接返回列表的函数12.在参数迭代时，要多加小心

抽象特点Python 一切皆对象，基于此概念，对 类 class 有以下特点：类与实例的属性类对象创建可选择定义类属性，创建实例对象时，实例属性自动执行类的__init__方法初始化实例对象自动继承相应的类属性（如果有），但实例属性优先级更高实例方法，类方法，静态方法的参数实例方法是一般函数但实例方法需要传入self参数（与一般函数的区别）类方法和静态方法是通过装饰器实现的函数，类方法需要传入cls参数，静态方法无需传入self参数或者是cls参数（但也能传入参数）其中self参数必须指向实例对象，cls参数指向定义的类对象（self与cls是约定俗成的，原则上可以用其它名字）方法与函数其中方法是在对象语境下的函数，实例调用实例方法即调用方法，类调用实例方法即调用函数具体细节类举例12345678910111213141516171819202122232425262728293031323334353637383940414243class Toy(object): # 此处此类可理解为设计一个Toy的蓝图  # 赋值定义类属性，记录所有玩具数量  count = 0   def __init__(self, name): # 用于实例初始化    self.name = name    # 类属性 +1    Toy.count += 1   @classmethod # 此装饰器表示是类方法，类方法无需创建实例对象即可调用，最为灵活  def show_toy_count(cls):    print('玩具对象的数量 %d' % cls.count, cls)   @staticmethod # 此装饰器表示是静态方法，静态方法本质上是封装在类对象内的的函数，常用于测试  def hi():    print('Hello!')   # 实例方法  def beybey(self):    print('Sad！', self)  # 创建实例对象toy1 = Toy('乐高')toy1.hand = 2toy2 = Toy('泰迪熊')toy3 = Toy('哥斯拉')print(toy1.name, toy2.name, toy3.name) # 点语法调用类方法与静态方法，如：类名.方法Toy.show_toy_count()Toy.hi()# 实例对象调用类方法时，与类对象调用类方法无异，但实际上调用仍通过实例对象继承的类对象toy1.show_toy_count()print(toy1.hand)# 实例对象调用静态方法时，与类对象调用静态方法无异，但实际上调用仍通过实例对象继承的类对象toy2.hi()# 实例对象调用实例方法,Python的解释器内部，当我们调用toy3.beybey()时，实际上Python解释成Toy.beybey(toy3)toy3.beybey()# Toy.beybey() # 错误语法，self必须指向实例对象，此处实例方法指向类对象而不是实例对象Toy.beybey(toy3)# 类与其实例的类型和内存地址print(type(Toy), id(Toy), type(toy3), id(toy3))输出结果乐高 泰迪熊 哥斯拉玩具对象的数量 3 <class '__main__.Toy'>Hello!玩具对象的数量 3 <class '__main__.Toy'>2Hello!Sad！ <__main__.Toy object at 0x000001FD9F794D60>Sad！ <__main__.Toy object at 0x000001FD9F794D60><class 'type'> 2188806599664 <class '__main__.Toy'> 2188813880672类方法与静态方法举例12345678910111213141516171819202122class Cat: # 或者class Cat()不写父对象形式定义类对象，会默认继承祖先object对象  name = '小敏'   @classmethod  def www(cls):    print('%s 干嘛！' % cls.name)    # cls.call() # 类方法可以调用静态方法   @staticmethod  def call():    print('喵喵～')    Cat.name = '小敏臭弟弟'    print(Cat.name)    # Cat.www() # 静态方法可以调用类方法  Cat.www()Cat.call()# 没有定义实例方法可以创建实例对象继承并使用其中方法cat1 = Cat()cat1.www()cat1.call()输出结果小敏 干嘛！喵喵～小敏臭弟弟小敏臭弟弟 干嘛！喵喵～小敏臭弟弟祖先对象中包含的基本方法123print(dir(object)) ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']总结类 class 是 Python 中最核心的对象，定义类通常要写好类属性，实例方法，类方法，静态方法等几部份。把类和继承的类的实例比作函数中的主函数和子函数，那么类属性可认为是全局变量，实例属性可认为是局部变量；把类看成葫芦，实例方法则是方便我们照画瓢的同时，提供因地制宜的可能；类方式能够使我们更高效的使用类的功能而静态方法往往能帮助我们了解类的功能。

python3读取python2打包的npy文件会报错，原因是编码方式不同，所以只要在读取的时候加上编码方式即可。解决方法12 docs_train = np.load('./data/20news_clean/train.txt.npy', allow_pickle=True, encoding='bytes')docs_test = np.load('./data/20news_clean/test.txt.npy', allow_pickle=True, encoding='bytes') 路径中的文件是python2打包的。补充：在Python 3中加载Python 2 .npy文件时出错我有.npy文件，它们是使用Python 2.7.9和Numpy版本1.11.3通过命令创建的np.save('filename')。这些文件是在外部计算机上生成的，该外部计算机是我们研究所的linux集群的一部分。我将文件复制到本地计算机上，以便通过导入它们np.load('filename.npy')。在我的本地计算机上，我正在运行带有Jupyter-Notebook的Python 3.5.2和Numpy版本1.13.0。本地操作系统是Ubuntu 16.04.2。当我尝试在本地加载文件时，出现错误：1 ValueError: invalid literal for int() with base 16 浏览了一些Stackoverflow问题后，我尝试使用以下方式指定编码：1 np.load('filename.npy',encoding='latin1') 这给出了相同的错误。encoding='bytes'产量：1 TypeError: can't multiply sequence by non-int of type 'float' 这是Traceback的较大片段： /usr/local/lib/python3.5/dist-packages/numpy/lib/npyio.py in load(file, mmap_mode, allow_pickle, fix_imports, encoding)417       else:418         return format.read_array(fid, allow_pickle=allow_pickle,--> 419                     pickle_kwargs=pickle_kwargs)420     else:421       # Try a pickle/usr/local/lib/python3.5/dist-packages/numpy/lib/format.py in read_array(fp, allow_pickle, pickle_kwargs)638       pickle_kwargs = {}639     try:--> 640       array = pickle.load(fp, **pickle_kwargs)641     except UnicodeError as err:642       if sys.version_info[0] >= 3:/usr/local/lib/python3.5/dist-packages/sympy/core/numbers.py in __new__(cls, num, prec)823         else:824           _mpf_ = mpmath.mpf(--> 825             S.NegativeOne**num[0]*num[1]*2**num[2])._mpf_826     elif isinstance(num, Float):827       _mpf_ = num._mpf_TypeError: can't multiply sequence by non-int of type 'float' 我猜想在Python和Numpy版本之间的转换时，编码有问题。关于如何导入文件的任何想法？解决方案如中所示，*。npy中数据的存储方式是什么？，.npy文件为字节码，如果您在十六进制编辑器中打开一个字节码，则会看到该文件。Python 2字节码.pyc，.pyo文件无法在Python 3中运行，因为虚拟机和编译器内部版本已随主要版本更改。同样，NumPy的C内部结构和字节码编译器在Python 3中也发生了变化，从而破坏了向后兼容性。（这是有意的，因为字节码并不是要持续那么长时间，或者不能与所创建的版本一起使用。）这些变更的组成意味着，如果不对Python 3的字节码解释器和Python

【Python编程创造营】已开课我们也特别为大家设置了【学习任务打卡】环节为的就是让大家巩固学习成果，紧跟学习进度现推出【问答官排位赛】，请各位同学详细查看本帖说明按要求格式回复即可获得积分累计阶段奖品，还能有机会获得附加幸运奖哦~ 活动时间：2021.03.20-2021.04.15.23:59  参与方式：用户在本帖里发布自己在Python学习中产生的疑惑或实践问题，其他用户可通过在楼层下评论参与回答。  参与规则：1. 同一ID不可自问自答；2. 同一ID可回复其他同一ID问题数量需≤3次，如，A最多可回答B的三个问题，但A可回答B、C、D、E、F等多人次问题。3. 每个人最多可发布10个有效问题，不可重复，不可灌水。4. 每个ID回答次数不设上限，但是否被采纳要依据专家评审后的结果。  活动奖励：由专家经过评审：（有效提问积分每周更新）◎每个有效提问可获得2积分。每周由专家评定，更新排行榜，上限为10个问题，不得灌水，不得与他人显示，问题具有意义，占楼无效。有效提问示例：无效提问示例：◎同一问题下确定一名最佳答案。共选出5名最佳答案，被采纳的回答者可获得10积分。（最佳问答官阶段末评出，积分阶段末统计）第二阶段5名最佳回答已产生，将获得额外10积分：@lwq1228 @蜡笔不辣 @zekelove @壹贰叁 @考过IE励志当攻城狮积分排行榜奖品 活动注意事项1. 学习任务提交后，小助手会在本阶段学习周期内，按序完成审核，并增加活动积分；2. 本次活动通过完成提交问答官问题，可获得的积分上限为2分/每个有效提问，每人最多10个有效提问；3. 请务必按照上述要求提交内容，以免影响积分增加；4. 若积分值相同则以完成学习任务的时间先后排序，其中任务完成时间的判定优先级为：结业考核>问答官排位赛>每周学习笔记>每章随堂测验打卡5. 其他积分获取方式请查看活动社群公告。想了解更多关于课程内容请移步主帖：https://bbs.huaweicloud.com/forum/thread-108015-1-1.html除了本帖任务，其他学习任务可以通过以下链接进行查看：查看章节测验打卡帖：https://bbs.huaweicloud.com/forum/thread-116565-1-1.html查看每周读书笔记打卡帖：https://bbs.huaweicloud.com/forum/thread-116566-1-1.html

（回复格式：华为云帐号+课程章节序号+截图）为了巩固大家的学习成果，紧跟学习进度请将需要完成的每周读书笔记内容按要求回复到本帖下方按要求格式回复即可获得积分累计阶段奖品，还能有机会获得附加幸运奖哦~打卡时间2021.03.29-2021.04.15 23:59打卡要求在本帖中，回复每周读书笔记和心得 ↓回复格式：华为云ID+第几周笔记+笔记内容，并分享些读书心得（字数≥200字）回复示例如下：奖励方式每周每次有效打卡可获得5积分阶段学习将以积分排行榜的形式，对前300名小伙伴进行奖励！此外还有附加奖励，每2周在提交读书笔记的用户中随机抽取5位送出幸运奖奖励华为云定制旅行本套装 积分排行榜奖品 活动注意事项 由于本帖回复内容为随堂测试结果，已设置回帖仅版主可见1. 学习任务提交后，小助手会在本阶段学习周期内，按序完成审核，并增加活动积分；2. 本次活动通过完成提交学习笔记任务，可获得的积分上限为5分/每周；3. 请务必按照上述要求提交内容，以免影响积分增加；4. 若积分值相同则以完成学习任务的时间先后排序，其中任务完成时间的判定优先级为：结业考核>问答官排位赛>每周学习笔记>每章随堂测验打卡5. 其他积分获取方式请查看活动社群公告。想了解更多关于课程内容请移步主帖：https://bbs.huaweicloud.com/forum/thread-108015-1-1.html除了本帖任务，其他学习任务可以通过以下链接进行查看：查看章节测验打卡帖：https://bbs.huaweicloud.com/forum/thread-116565-1-1.html查看问答官排位赛活动帖：https://bbs.huaweicloud.com/forum/thread-116570-1-1.html

（回复格式：华为云帐号+课程章节序号+截图）为了巩固大家的学习成果，紧跟学习进度请将需要完成的每章随堂测验内容按要求回复到本帖下方按要求格式回复即可获得积分累计阶段奖品，还能有机会获得附加幸运奖哦~打卡时间2021.03.29-2021.04.15 23:59打卡要求在本帖中，回复对应章节的随堂测验并提交截图 ↓回复格式：自己的华为云ID+课堂章节序号+课程完成截图（露出右上角华为云ID，随堂测验为绿色对勾完成状态）回复示例：华为云帐号：grandmaster+第一章 程序员的好助手-Python奖励方式每章节每次有效打卡可获得2积分阶段学习将以积分排行榜的形式，对前300名小伙伴进行奖励！此外还有附加奖励，每2周在提交随堂测验的用户中随机抽取5位送出幸运奖奖励华为云定制敏捷扑克牌 积分排行榜奖品 活动注意事项 由于本帖回复内容为随堂测试结果，已设置回帖仅版主可见1. 学习任务提交后，小助手会在本阶段学习周期内，按序完成审核，并增加活动积分；2. 本次活动通过完成每章习题打卡任务，可获得的积分上限为2分/每章节；3. 请务必按照上述要求提交内容，以免影响积分增加；4. 若积分值相同则以完成学习任务的时间先后排序，其中任务完成时间的判定优先级为：结业考核>问答官排位赛>每周学习笔记>每章随堂测验打卡5. 其他积分获取方式请查看活动社群公告。想了解更多关于课程内容请移步主帖：https://bbs.huaweicloud.com/forum/thread-108015-1-1.html除了本帖任务，其他学习任务可以通过以下链接进行查看：查看学习笔记打卡帖：https://bbs.huaweicloud.com/forum/thread-116566-1-1.html查看问答官排位赛活动帖：https://bbs.huaweicloud.com/forum/thread-116570-1-1.html

1说明写了python文件，想通过命令执行它，进入目录，并在命令执行中输入python文件名称。2、实例例如，桌子上有文件hello.py，内容是印刷一句话print("Hello, Python")要运行它，首先进入Desktop目录，然后在命令行中输入pythonhello.py即可运行：Solo-mac:Desktop solo$ python hello.pyHello, Python知识点扩展：在命令行中运行python代码是很常见的，下面介绍如何定义命令后面跟的参数。常规用法import argparse   parser = argparse.ArgumentParser("Description.") # ————1————parser.add_argument('--test1', type=str, default="1", help="Test1 help.") # ————2————parser.add_argument('--test2', type=float, default=2.1, help="Test2 help.") # ————2————args = parser.parse_args() # ————3———— print(args)test1, test2 = args.test1, args.test2 # ————4———— print(type(test1), test1, test1 + " add test") print(type(test2), test2, test2 + 100)注释：1、获取外部参数对象实例。可以传入字符串来描述总体的外部参数。2、定义外部参数，可以多次调用来定义多个外部参数。函数的第一个参数是外部参数的名称，建议以两个减号开头，中间不要使用数字字母下划线以外的符号，否则容易出错。type是你希望外部参数传入后转换的类型，比如--test1定义为str，即使命令行传参不添加引号，函数也将它转换为字符串（当然不加引号传字符串就不能用空格了）。而--test2是float，即使命令行传参带了引号，只要能转换为数字，函数都能转换为float类型。default是外部参数的默认值。如果命令行不对外部参数赋值而使用默认值，函数不会对你定义的默认值进行type上的转换，所以default最好直接定义为type指定的类型（比如--test1的default定义为"1"而不是1）。help传入对当前外部参数的描述，命令行中使用--help输出的就是这个。3、分析获取的外部参数。传出的是一个命名空间，类似于字典，但使用属性的方式而不是key索引来获取命名对应的外部参数值。4、以获取属性的方式获取外部参数。需要注意的是，外部参数的定义必须写在获取外部参数之前。也就是说，parser.add_argument()要写在parser.parse_args()之前，否则外部参数无法被命令行捕获。另外，如果代码中没有parser.parse_args()，命令行就不能传参。

Python 语言里有许多（而且是越来越多）的高级特性，是 Python 发烧友们非常喜欢的。在这些人的眼里，能够写出那些一般开发者看不懂的高级特性，就是高手，就是大神。但你要知道，在团队合作里，炫技是大忌。为什么这么说呢？我说下自己的看法：越简洁的代码，越清晰的逻辑，就越不容易出错；在团队合作中，你的代码不只有你在维护，降低别人的阅读/理解代码逻辑的成本是一个良好的品德简单的代码，只会用到最基本的语法糖，复杂的高级特性，会有更多的依赖（如语言的版本） 1. 最直观的相加使用 + 对多个列表进行相加，你应该懂，不多说了。>>> list01 = [1,2,3]>>> list02 = [4,5,6]>>> list03 = [7,8,9]>>>>>> list01 + list02 + list03[1, 2, 3, 4, 5, 6, 7, 8, 9]>>>  2. 借助 itertoolsitertools 在 Python 里有一个非常强大的内置模块，它专门用于操作可迭代对象。在前面的文章中也介绍过，使用 itertools.chain() 函数先可迭代对象（在这里指的是列表）串联起来，组成一个更大的可迭代对象。最后你再利用 list 将其转化为 列表。>>> from functools import chain>>> list01 = [1,2,3]>>> list02 = [4,5,6]>>> list03 = [7,8,9]>>>>>> list(chain(list01, list02, list03))[1, 2, 3, 4, 5, 6, 7, 8, 9]>>> 3. 使用 * 解包使用 * 可以解包列表。 *  和 ** 常用在函数定义时，设置可变参数。现在我将它单独拿出来用在多个列表的合并。示例如下：>>> list01 = [1,2,3]>>> list02 = [4,5,6]>>>>>> [*list01, *list02][1, 2, 3, 4, 5, 6]>>> 4. 使用 extend在字典中，使用 update 可实现原地更新，而在列表中，使用 extend 可实现列表的自我扩展。>> list01 = [1,2,3]>>> list02 = [4,5,6]>>>>>> list01.extend(list02)>>> list01[1, 2, 3, 4, 5, 6] 5. 使用列表推导式Python 里对于生成列表、集合、字典，有一套非常 Pythonnic 的写法。那就是列表解析式，集合解析式和字典解析式，通常是 Python 发烧友的最爱，那么今天的主题：列表合并，列表推导式还能否胜任呢？当然可以，具体示例代码如下：>>> list01 = [1,2,3]>>> list02 = [4,5,6]>>> list03 = [7,8,9]>>>>>> [x for l in (list01, list02, list03) for x in l][1, 2, 3, 4, 5, 6, 7, 8, 9]>>> 6. 使用 heapqheapq 是 Python 的一个标准模块，它提供了堆排序算法的实现。该模块里有一个 merge 方法，可以用于合并多个列表，如下所示>>> list01 = [1,2,3]>>> list02 = [4,5,6]>>> list03 = [7,8,9]>>>>>> from heapq import merge>>>>>> list(merge(list01, list02, list03))[1, 2, 3, 4, 5, 6, 7, 8, 9]>>> 要注意的是，heapq.merge 除了合并多个列表外，它还会将合并后的最终的列表进行排序。>>> list01 = [2,5,3]>>> list02 = [1,4,6]>>> list03 = [7,9,8]>>> >>> from heapq import merge>>> >>> list(merge(list01, list02, list03))[1, 2, 4, 5, 3, 6, 7, 9, 8]>>> 它的效果等价于下面这行代码：1sorted(itertools.chain(*iterables))如果你希望得到一个始终有序的列表，那请第一时间想到 heapq.merge，因为它采用堆排序，效率非常高。但若你不希望得到一个排过序的列表，就不要使用它了。 7. 借助魔法方法利用魔法方法 __add__，实际 上当我们使用第一种方法 list01 + list02 的时候，内部实际上是作用在 __add__ 这个魔法方法上的.所以以下两种方法其实是等价的>>> list01 = [1,2,3]>>> list02 = [4,5,6]>>> >>> list01 + list02[1, 2, 3, 4, 5, 6]>>> >>> >>> list01.__add__(list02)[1, 2, 3, 4, 5, 6]>>> 借用这个魔法特性，我们可以 reduce 这个方法来对多个列表进行合并，示例代码如下>>> list01 = [1,2,3]>>> list02 = [4,5,6]>>> list03 = [7,8,9]>>>>>> from functools import reduce>>> reduce(list.__add__, (list01, list02, list03))[1, 2, 3, 4, 5, 6, 7, 8, 9]>>> 8. 使用 yield fromyield from 后可接一个可迭代对象，用于迭代并返回其中的每一个元素。因此，我们可以像下面这样自定义一个合并列表的工具函数。>>> list01 = [1,2,3]>>> list02 = [4,5,6]>>> list03 = [7,8,9]>>>>>> def merge(*lists):...   for l in lists:...     yield from l...>>> list(merge(list01, list02, list03))[1, 2, 3, 4, 5, 6, 7, 8, 9]>>>看到这里，有没有涨姿势了，学了这么久的 Python ，没想到合并列表还有这么多的方法。本篇文章的主旨，并不在于让你全部掌握这 7 种合并列表的方法，实际上，你只要选用一种最顺手的方式即可。但是在协同工作中，或者在阅读他人代码时，你不可避免地会碰到各式各样的写法，这时候你能下意识的知道这是在做合并列表的操作，那这篇文章就是有意义的。

当前有一组成绩单： score = [100,79,65,87,97,65,87,97,67] 请去除成绩单中成绩大于 80 的成绩，并将取出后的列表打印出来分享一下，感兴趣的可以自己写写，有意外惊喜！注意：缩进缩进。。。score = [100,79,65,87,97,65,87,97,67]score1 = score.copy()print(score1)for i in range(1,len(score)+1):  if(score1[len(score)-i]>80):    score1.pop(len(score)-i)print(score)