Python函数和面向对象，小白看了都说好
python除了使用内置函数以外，还可以自定义函数。我们为什么要定义和使用函数呢？
下面我举个例子，比如我想求10的阶乘
m = 1
for i in range(1, 11):
m *= i
print(m)
代码虽然不长，但是如果我还想求20，21，55，100的阶乘呢？按照上面的方式求几个数的阶乘就要写几个循环，这样我们也能得到想要的答案，但代码是不是显得’难看‘。这时候我们就可以定义一个函数，以后求阶乘只需要调用这个函数就行了。
def fac(n):
result = 1
for i in range(1, n + 1):
result *= i
return result
fac(8)
fac(25)
fac(63)
fac(100)
是不是感觉很方便呢？接下来给大家介绍一下函数用法
定义函数
定义一个python函数，下面是函数的基本形式：
def 函数名(参数1，参数2，…，参数n):
? 函数体
? return 返回值
我们可以看到python用def来定义一个函数，后面有函数名和英文括号（括号里面可以定义一些参数，参数可以根据具体需求设置，也可以没有参数，参数还可以设置默认值）。下面return可以返回一个值，这个值有时任何形式的数据，当然也可以没有返回值。
接下来是一些实例：
实例1：
def hello_world():
return 'hello, world'
print(hello_world())
实例2：
def hello(name):
print(f'你好，{name}')
hello('百里守约')
实例3：
def add(nums):
sum = 0
for n in nums:
sum += n
return sum
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(add(nums))
函数的返回值
return：返回值，如果没有则默认返回None
实例：
def num() :
s = 10
return s
def num2():
s = 10
a = num()
b = num2()
print(a, b)
实例：
s = 'hello, 张三'
return s
def hello2():
print('hello, jack')
a = hello()
print(a)
b = hello2()
函数参数
函数可以设置参数，也可以不设置参数，可以设置一个参数，也可以设置多个参数，同时函数也可以设置默认值。
实例：
import random
def roll_dice(n=2):
"""摇色子
:param n: 色子个数，默认两个色子
:return: 返回色子的总点数
"""
points = 0
for _ in range(n):
points += random.randrange(1, 7)
return points
print(roll_dice())
print(roll_dice(3))
实例：
def BMI(high, weight, sex):
"""
体质指数计算
:param high:身高 ，单位：米
:param weight:体重，单位：千克、公斤
:param sex:性别，男：1，女：0
:return: 返回体质指数
"""
bmi = weight / high ** 2
if sex == 0:
bmi -= 1.1
if bmi < 19:
print('体重偏轻')
elif 19 <= bmi < 25:
print('健康体重')
elif 25 <= bmi < 30:
print('超重')
elif 30 <= bmi < 39:
print('严重超重')
else:
print('极度超重')
return weight / high ** 2
print(BMI(1.6, 50, 1))
此时我们在设置了三个参数，当调用函数时，我们也必须传入三个参数，输入参数 的位置默认和设置参数的位置一致。如果参数有默认值，则调用函数时，带有默认值的参数可以不必输入。
实例
def sum(a, b):
"""
加法函数，将a和b相加
:param a: 加数
:param b: 加数
:return: 返回相加之和
"""
return a+b
print(sum(1, 2))
实例：
def sum(a, b, c, d, e):
"""
加法函数，将a, b, c, d, e相加
:return: 返回相加之和
"""
return a+b+c+d+e
print(sum(1, 2, 3, 4, 5))
当输入的参数过多，并且参数的属性一致时，我们可以使用可变参数
可变参数
def sum(*a):
"""
加法函数
:param a: 表示一个可变参数，存储任意多参数，此时a为一个元组
:return: 返回相加之和
"""
m = 0
for i in a:
m += i
return m
print(sum(1, 2, 3))
print(sum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
在参数前面加*号，此时参数为可变参数。可变参数为一个元组，将所有多余的参数全部存在里面。
同时我们可以在不同的项目中调用函数
实例：
module1.py
def hello():
print('hello, world')
module2.py
def hello():
print('goodbye, world')
test.py
import module1
import module2
module1.hello()
module2.hello()
在导入模块时，还可以使用as关键字对模块进行别名，这样我们可以使用更为简短的完全限定名。
import module1 as m1
import module2 as m2
m1.hello()
m2.hello()
如果我们用from…import…的形式，我们必须使用as关键字对导入函数进行别名，不然两个相同的hello函数，其中一个会被覆盖。
from module1 import hello as h1
from module2 import hello as h2
h1()
h2()
标准库中的模块和函数
| 函数 | 说明 |
|---|
abs | 返回一个数的绝对值，例如：abs(-1.3)会返回1.3。 | bin | 把一个整数转换成以'0b'开头的二进制字符串，例如：bin(123)会返回'0b1111011'。 | chr | 将Unicode编码转换成对应的字符，例如：chr(8364)会返回'�'。 | hex | 将一个整数转换成以'0x'开头的十六进制字符串，例如：hex(123)会返回'0x7b'。 | input | 从输入中读取一行，返回读到的字符串。 | len | 获取字符串、列表等的长度。 | max | 返回多个参数或一个可迭代对象（后面会讲）中的最大值，例如：max(12, 95, 37)会返回95。 | min | 返回多个参数或一个可迭代对象（后面会讲）中的最小值，例如：min(12, 95, 37)会返回12。 | oct | 把一个整数转换成以'0o'开头的八进制字符串，例如：oct(123)会返回'0o173'。 | open | 打开一个文件并返回文件对象（后面会讲）。 | ord | 将字符转换成对应的Unicode编码，例如：ord('�')会返回8364。 | pow | 求幂运算，例如：pow(2, 3)会返回8；pow(2, 0.5)会返回1.4142135623730951。 | print | 打印输出。 | range | 构造一个范围序列，例如：range(100)会产生0到99的整数序列。 | round | 按照指定的精度对数值进行四舍五入，例如：round(1.23456, 4)会返回1.2346。 | sum | 对一个序列中的项从左到右进行求和运算，例如：sum(range(1, 101))会返回5050。 | type | 返回对象的类型，例如：type(10)会返回int；而type('hello')会返回str。 |
函数进阶
位置参数和关键字参数
def add(a,b,c):
当我想调用函数add时，如add(1,2,3)，此时a = 1,b = 2,c = 3，也就是说，传入的参数值与原来函数的参数位置一一对应。此时参数都是位置参数，当然，我们也可以通过参数名=参数值的方式进行传参，如add(a=1,c=3,b=2)，因为传入参数时带上了参数名，所以参数位置可以随意改变。
如果我们希望调用函数时必须以参数名=参数值的格式进行传参，我们对函数参数做如下改变：
def add(*，a,b,c):
如此，如果想调用add函数，必须要以参数名=参数值的格式进行传参，否则就会引发异常，这时候的参数我们称之为关键字参数。
| 参数形式 | 参数类型 | 使用实例 |
|---|
| def add(a, b, c) | a、b、c 都是位置参数 | add(1, 2, 3) | | def add(*, a, b, c) | a、b、c 都是关键字参数 | add( a = 1, b = 2, c = 3) | | def add(a, *, b, c) | a 是位置参数，b、c 是关键字参数 | add( 1, b = 2, c = 3) |
简单来说，* 前面的参数都是位置参数， * 后面的参数都是关键字参数
前面我们说到可变参数 （ *参数名 ）可以容纳任意多的参数个数，我们在设计函数时，如果既不知道调用者会传入的参数个数，也不知道调用者会不会指定参数名，那么同时使用可变参数和关键字参数。关键字参数会将传入的带参数名的参数组装成一个字典，参数名就是字典中键值对的键，而参数值就是字典中键值对的值
def calc(*args, **kwargs):
*args 为可变参数，返回的是一个元组
**kwargs 为可变的关键字参数，返回的是一个字典
实例：
def sum(*args, **kwargs):
result = 0
for arg in args:
result += arg
for value in kwargs.values():
result += value
return result
print(sum(1, 3, 5))
print(sum(a = 1, b = 4, c = 3))
print(sum(1, 5, c = 7, d = 3))
设计函数时，位置参数必须在关键字参数前面；没有默认值的参数必须在有默认值的参数前面。
高级函数
函数本身也可以作为函数的参数或者返回值，这样的函数我们称之为高级函数。
def add(num1, num2):
return num1 + num2
def sub(num1, num2):
return num1 - num2
def mul(num1, num2):
return num1 * num2
def div(num1, num2):
return num1 / num2
def sum(*args, start, ft, **kwargs):
"""
高级函数，自由实现多个数的四则运算
start：开始值，加法运算时为0，减法、乘法、除法运算时为0
ft：函数名
"""
result = start_value
for arg in args:
result = ft(result, arg)
for value in kwargs.values():
result = ft(result, value)
return result
print(sum(1, 3, 5, start = 0, ft = add, a = 1, b = 4, c = 3))
print(sum(1, 3, 5, start = 1, ft = sub, a = 1, b = 4, c = 3))
print(sum(1, 3, 5, start = 1, ft = mul, a = 1, b = 4, c = 3))
print(sum(1, 3, 5, start = 1, ft = div, a = 1, b = 4, c = 3))
此时函数sum已经不局限于一个加法函数，而是可以轻松可以进行四则运算里面任何一个计算方式。需要注意的是，将函数作为参数和调用函数是有显著的区别的，调用函数需要在函数名后面跟上圆括号，而把函数作为参数时只需要函数名即可。我们还可以直接调python标准库中operator模块，它可以提供加法乘法运算，我们直接使用即可。
Lambda函数（匿名函数）
Lambda函数又叫你们函数是一种没有函数名的函数
表达式 ------- lambda 参数1 , …, 参数n : 执行体
执行体通常是一个表达式，其返回值通常就是运算结果
实例：
def sum(*args, start=0, ft=lambda x, y: x + y, **kwargs):
result = start
for arg in args:
result = ft(result, arg)
for value in kwargs.values():
result = ft(result, value)
return result
print(sum(1, 3, 5, x = 7, y = 9))
print(sum(1, 3, 5, x = 7, y = 9, start = 1, ft = lambda x, y: x * y))
面向对象
首先给大家介绍几个重要的概念。
-
类、对象 类是一个抽象的概念，对象是类的具体实现。 把属于同一个类的共同特征提取出来，我们就得到一个类，比如人是一个类，小明、张三、李四就是一个具体的对象； 天体是一个类，那么地球、火星、月球就是一个具体的对象。 -
封装、继承、多态 封装：把数据和操作数据的函数从逻辑上组装成一个整体（对象）。隐藏实现细节，暴露简单的调用接口。
继承：扩展已有的类创建新类，实现对已有类的代码复用。
多态：给不同的对象发出同样的消息，不同的对象执行了不同的行为。
简单概括一下面向对象编程就是：把一组数据和处理数据的方法组成对象，把行为相同的对象归纳为类，通过封装隐藏对象的内部细节，通过继承实现类的特化和泛化，通过多态实现基于对象类型的动态分派。是一种重要的编程思维和方式。
定义类
加上类名来定义类，通过缩进我们可以确定类的代码块，就如同定义函数那样。在类的代码块中，我们需要写一些函数，我们说过类是一个抽象概念，那么这些函数就是我们对一类对象共同的动态特征的提取。写在类里面的函数我们通常称之为方法，方法就是对象的行为，也就是对象可以接收的消息。方法的第一个参数通常都是self，它代表了接收这个消息的对象本身。
class Student:
def study(self, name, course):
print(f'{name}正在学习{course}。')
def play(self, name, game):
print(f'{name}正在玩{game}')
创建和使用对象
class Student:
def study(self, course):
print(f'学习{course}。')
def play(self, name, game):
print(f'玩{game}')
if __name__ == '__main__':
student1 = Student()
student2 = Student()
student1.study('语文')
student2.study('数学')
student1.play('连连看')
student1.play('推箱子')
初始化方法
我们可以通过给Student类添加__init__方法的方式为学生对象指定属性，同时完成对属性赋初始值的操作，这个方法方法通常也被称为初始化方法。我们对上面的Student类修改，给学生对象添加name（姓名）和age（年龄）两个属性。
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def study(self, course):
print(f'{self.name}学习{course}。')
def play(self, game):
print(f'{self.name}玩{game}')
if __name__ == '__main__':
student1 = Student('张三', 15)
student2 = Student('李四', 16)
student1.study('语文')
student2.study('数学')
student1.play('连连看')
student1.play('推箱子')
在Python中，以两个下划线开头和结尾的方法，我们一般称之为魔术方法或魔法方法。通过__repr__魔术方法，如果我们在打印对象的时候看到的是我们自定义的信息，该方法返回的字符串就是用print函数打印对象的时候会显示的内容。
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def study(self, course):
print(f'{self.name}学习{course}。')
def play(self, game):
print(f'{self.name}玩{game}')
def __repr__(self):
return f'{self.name}: {self.age}'
if __name__ == '__main__':
student1 = Student('张三', 15)
print(student1)
students = [student1, Student('老李四', 16), Student('王五', 25)]
print(students)
小程序：
class Clock:
"""时间"""
def __init__(self, hour=0, minute=0, second=0):
self.second = second
self.minute = minute
self.hour = hour
def run(self):
self.second += 1
if self.second == 60:
self.second = 0
self.minute += 1
if self.minute == 60:
self.minute = 0
self.hour += 1
if self.hour == 24:
self.hour = 0
def show(self):
return f'{self.hour:0>2d}:{self.minute:0>2d}:{self.second:0>2d}'
if __name__ == '__main__':
clock = Clock(23, 59, 50)
while True:
os.system('cls')
print(clock.show())
time.sleep(1)
clock.run()
后续还会继续更新，感兴趣的伙伴可以留意
|