python如何删除excel中不满足要求的工作簿(excel怎么删除工作表里不需要的)
727
2022-05-30
Python函数教程
函数本身其实就相当于一个集装箱,她负责把我们之前写的那些代码装进去,她在打包的时候会在箱子的上下各开两个透气的口子,上面的口子叫参数,下面的口子叫返回值~~~~~(当然你也可以选择性的关闭这两个口子哦)
"""
python定义函数, 对代码进行封装,python也是引用传递,而不是值传递
1- 如果函数名一样,python并不会报错,而是会覆盖
def 函数名(参数)
"""
def my_print():
print("HAHAHHA")
def my_print():
print("HAHAHHA22222")
for i in range(5):
my_print()
# 如果提示shadows in xxx build in是因为你定义的函数名和内置的函数名一样,比如sum()
def my_sum(a, b):
print("a + b = %d" % (a + b))
my_sum(1,5)
# 带有返回值的函数, 使用 -> 的方式,和typescript类似
def my_sum(a, b) -> int:
return (a + b)
print("a + b = %d" % my_sum(1, 5))
"""
函数的嵌套调用,就是函数中调用另一个函数
1- my_func02 必须定义在My_func01之前,真正调用的时候才会加载,并不会全局预加载
2- 内置函数的作用域,不会自动调用
"""
def my_func02():
print("C")
print("D")
def my_func01():
print("A")
my_func02()
print("B")
my_func01()
def my_func03():
print("A")
# 内置def函数,注意作用域, 注意内置函数不会自动调用
def my_func04():
print("C")
my_func04()
print("D")
print("B")
my_func03()
# 函数参数的乱序位置,也可以像kotlin一样添加关键字参数
# 注意:如果某个参数使用了关键字参数,那么之后的参数必须都必须使用关键字参数
# 换句话说,就是参数可以合理的一一对应,开发中一般很少使用关键字参数,看懂即可
def get_info(name, age) -> str:
return "name: %s, age: %s" % (name, age)
print(get_info(age= "26", name="张三"))
"""
缺省函数,就是参数可以有默认值,跟kotlin一样
返回值也可以简写,省略 -> int:
"""
def print_info(name, age=20):
print("姓名:%s, 年龄:%s" % (name, age))
print_info("张三", 28)
print_info("李四")
"""
元组[]不定长参数,参数的数量不确定, 调用类似于位置参数
参数名之前加上*表示这个星号表明参数的类型为元祖,但是传入实参的时候不需要中括号[]
"""
def my_func01(*args):
print(type(args))
print(args[0])
my_func01(1, 3, 5)
my_func01(1, 3, 5, 7)
"""
字典类型{}的不定长参数, 调用类似于关键字参数name=的形式
参数名前面加上**两个星号,表明这个参数为一个字典,传入的时候不需要写{},但是只能传入一个字典
"""
def my_func02(**kwargs):
print(type(kwargs))
print(kwargs["name"])
print(kwargs["age"])
my_func02(name="小明", age=12)
"""
一个函数的包含多return个
"""
def my_func03(score: int) -> str:
if score >= 70:
return "优秀"
elif score >= 30:
return "中性"
else:
return "差"
print(my_func03(50))
"""
处理多个返回值的方式
1- return ["小明", 28]
2- return {"name":"小明","age":28]
2- return 返回值1, 返回值2
"""
def my_func04(name, age):
return name, age
print(my_func04("张三",28)[0])
print(my_func04("张三",28)[1])
"""
python中的拆包(列表,字典,多个返回值): 一次性初始化多个变量的值
如果返回值是列表,字典,或者多个返回值,可以直接用来赋值多个变量的方式就叫做拆包,简化代码量
"""
num01, num02, num03, num04 = 1, 3.14, True, "Hello World"
num05, num06, num07, num08 = [1, 3.14, True, "Hello World"]
name, age = my_func04("李四", 28)
print(name, "-->", age)
"""
拆包中python快速交换两个变量的值, 免去了temp中间值
"""
a, b = 4, 5
a, b = b, a # b的引用给a, a的引用给b,快速交换值
"""
函数中的局部变量的释放狮是在函数执行完后就马上消失
全局变量是等真个程序运行完后进行销毁,作用域是整个函数
1- 如果局部变量名和全局的相同,那么执行的时候根据就近原则
2- 如果函数内找不到该变量名,那么就去找全局变量
3- 如果函数内想要就该外面的全局变量,使用globe关键字
"""
num = 10
def my_func01():
# num = 20 这里是创建一个新的内部变量
global num
num = 20 # 这里告诉函数并非创建新的局部变量,而是使用全局的变量操作
print("内部num = %s" % num)
my_func01()
print("外部num = %s" % num)
"""
函数自建函数文档说明help(len)
如果函数内没有自定义文档说明,那么就返回找函数名上面一行的注释
"""
help(len)
# 这里是没有专门的说明进行返回的内容
def my_func02(num01, num02):
"""
返回两个参数的和
:param num01: 数字1
:param num02: 数字2
:return: 两个数字的和
"""
return num01 + num02
help(my_func02)
"""
id(obj)查找obj内存的物理地址引用门牌号
类似:定了一个房间但是没有入住,调用的时候才入住
a,b指向同一个房间,节省内存
"""
a = 1000
b = 1000
c = "abc" # 字符串,元祖()等不可不的数据类型,修改的话是copy重新开一个房间
d = "abc" # 列表[],字典可变数据结构,修改的话是在同一个房间进行修改的。
c = "abcd"
print(id(a))
print(id(b))
print(id(c))
print(id(d))
Python函数---递归专栏
这个说起来就比较烦了,简而言之就是自己用自己。
"""
斐波那契
python中的递归函数, time模块中的sleep(单位是秒s)
1- 用现有的while循环来实现
2- 递归实现,必须有一个停止的条件来调用自己
"""
"""
原理:
n! = {
if -> n * (n - 1)! if( n>=0)
else -> 1 if( n=0)
}
1- f(3) -> 3*f(2)
2- f(2) -> 2*f(1)
3- f(1) -> 1*f(0)
4- f(0) -> return 1
"""
def c_func(num):
if num > 1:
return num * c_func(num - 1)
else:
return 1
print(c_func(3))
"""
递归的核心就是将表达式分部分,重复的部分和截至的部分
递归求fib序列: 1 1 2 3 5 8
fib(n) = {
n = fib(n-2) + fib(n-1) if n>2
n = 1 else (n=1 or n=2)
}
"""
def d_func(num):
if num > 2:
return d_func(num - 2) + d_func(num - 1)
else:
return 1
print(d_func(6))
"""
lambda关键字表示这是一个匿名函数,通过小括号来执行()
"""
# 无参数无返回值
def f_func():
print("Hello World 1")
f_func()
a_lambda = lambda: {
print("Hello World 2")
}
a_lambda()
(lambda: {print("Hello World 3")})()
# 无参数有返回值, lambda冒号后面不用写return
def e_func():
return "Hello World 4"
print(e_func())
print((lambda: "Hello World 5")())
# 有参数,无返回值,参数写在lambda后面,冒号前面
def f_func(name):
print(("Hello World 6 --> %s" % name))
f_func("张三")
(lambda name: {print(("Hello World 7 --> %s" % name))})("张三")
# 有参数,有返回值
def g_func(name):
return "Hello World 8 --> %s" % name
print(g_func("李四"))
print((lambda name: {"Hello World 9 --> %s" % name})("李四"))
"""
匿名函数lambda作为函数参数
函数内a,b进行特定操作后,最后交给callback进行回掉
"""
def h_func(a, b, callback):
print("result = %d" % callback(a, b))
# lambda a,b: a + b
h_func(3, 5, lambda a, b: a + b)
Python类教程(面向对象)
如果说函数是一个集装箱,那么类就是一个放集装箱的大仓库。我们把作一类事情的函数都会放到一个类里面。这样我们的代码就会更加美观,更加方便看懂。
class Person(object):
def __init__(self, name, age, num):
self.name = name
self.age = age
self.num = num
def __str__(self):
return "姓名:%s 年龄: %s 学号: %s" % (self.name, self.age, self.num)
def __del__(self):
# 监听对象销毁,可以用来用户复活
print("再见")
def print_info(self):
print("姓名:%s 年龄: %s 学号: %s" % (self.name, self.age,self.num))
p1 = Person("张三", 18, 1605477)
print(p1)
p2 = p1 # 引用计数+1
p3 = p1 # 引用计数+1
del p1 # 引用计数-1
del p2 # 引用计数-1
del p3 # 引用计数=0
# input()
"""
1- 使用同一个类创建的不同对象,**属性**是需要单独开辟内存的,防止一损俱损
2- 但是类的自定义方法是唯一的只有一份内存, 是通过self判断不同的调用对象是谁
"""
p4 = Person("张三", 18, 1605477)
p5 = Person("张三", 18, 1605477)
print(id(p4.name)) # name作为类属性,有单独的内存空间,id地址不同
print(id(p5.name)) # 但是因为小整数型原因,显示的id相同,但原理id是不同的
print(id(p4.print_info())) # 类方法是唯一一份的,所以id相同
print(id(p5.print_info()))
"""
单继承,class B(A) 括号里面的是相对B来说的B的父类,集成了A的属性和方法
1- python中类的属性是直接写在init方法中的
"""
class A(object):
def __init__(self):
self.num = 10
def print_num(self):
print(self.num + 10)
class B(A):
def my_func(self):
print("我自己B类的自定义方法")
b = B()
print(b.num)
b.print_num()
b.my_func()
"""
多继承class D(C, A),如果多个父类C,A中都含有相同的方法和属性print_num那么子类D继承的是就是C的,注意继承的先后顺序
1- 父类中的属性和方法如果相同的话,会继承第一个父类的属性和方法,按照集成的顺序走init构造方法
2- D类中重写父类的方法,如果自己d类中重写了init方法,那么就不会继承任何的父类属性从init方法中
3- 换句话,子类重写了父类的方法,那么不在使用父类同名的方法,包括init构造方法
4- 子类中重写了父类的方法但是还是想调用父类的方法,
"""
class C(object):
def __init__(self):
self.num = 28
def print_num(self):
print(self.num + 10)
class D(C, A):
def __init__(self):
self.age = "这是D类自己的属性age"
self.num = "这是D类重写父类的属性num"
def print_num(self):
self.__init__() # 再将self.num更改回来
print("这是D自己重写父类的方法")
# 但是子类还是想使用**父类的属性**调用父类重名的print_num方法
# 使用A.__init__(self)方法来更改self.num的值
def print_a_num(self):
print(d.num) # 本来D对象中self.num = "这是D类重写父类的属性num"
A.__init__(self) # 把self传进去,当前的self.num = 10
A.print_num(self)
# 或者使用super在子类方法中调用父类的方法
def print_c_num(self):
# super(D, self).print_num() 或者下面的简写形式
super().print_num()
def my_func(self):
print("我自己D类的自定义方法")
d = D()
d.print_a_num()
print(d.num)
d.print_num()
"""
类中的私有属性和方法
1- 父类中的money不想让子类继承,进行私有self.__属性名
2- 方法前加上两个下划线使方法私有化, 私有的属性和方法只能在类内使用
3- # 私有属性子类不能使用,相当于java中的对象不能加点来获取private的属性值
"""
class Master(object):
def __init__(self):
self.kongfu = "古法"
self.__money = 100000 # 两个下划线开头表示私有属性
def make_cake(self):
print(self.__money) # 私有属性可以在类自己种使用
print("制作古法煎饼果子")
def __hello_python(self):
print("你好python")
lishifu = Master()
lishifu.make_cake()
print(lishifu.kongfu)
# print(lishifu.money)
"""
子类不能继承父类的私有属性和方法
因为根本没有继承下来,所以子类内部方法中根本就不能调用父类的私有属性和方法
"""
class Prentice(Master):
def xx(self):
print("xx")
self.__hello_python()
damao = Prentice()
print(damao.kongfu)
damao.__hello_python
damao.xx()
Python
版权声明:本文内容由网络用户投稿,版权归原作者所有,本站不拥有其著作权,亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容,请联系我们jiasou666@gmail.com 处理,核实后本网站将在24小时内删除侵权内容。