Python封装

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