Python基础进阶：从函数到高级魔法方法

学习内容概括

天池龙珠计划 Python训练营
7天 21小时，入门python，迈出AI第一步

学习地址

https://tianchi.aliyun.com/specials/promotion/aicamppython

具体学习内容

函数

在计算机中称之为函数，在现实生活中称之为功能。 函数是能够实现特定功能的计算机代码，它是一种特定的代码组结构。

函数的作用

1.提高代码的重复利用率，避免重复开发相同代码
2.提高程序的开发效率
3.便于程序维护

函数名的命名规则

1.推荐使用英文，禁止使用中文
2.可以使用数字，但不能以数字开头
3.不可以使用特殊字符，除了下划线_
4.函数名严格区分大小写
5.函数名必须要有意义
6.不能和系统保留关键字冲突

函数的定义

基本格式

def 函数名():
    pass

示例：

#定义函数
def funName():
    pass #此处编写功能代码

funName() #调用

'''注释：
函数的特征：函数定义之后，不会自动执行，只会在调用的时候执行。不调用，不执行。
'''

带有参数的格式

def 函数名(参数1，参数2...):
    pass

示例：

#定义带有参数的函数
def funName(arg):
    print('接收到的参数：',arg)

funName(666) #调用

'''注释：
形参：形式上的参数，声明函数时，括号()中的参数，是形参。
实参：实际上的参数，调用函数是，括号()中的参数，是实参。
实参将值传递给形参的本质过程，本质上就是简单的变量赋值。
'''

带有默认值的参数的格式

def 函数名(参数1 = 值1,参数2 = 值2...):
    pass

示例：

#定义带有默认值参数的函数
def funName(arg = 'jack'):
    print('参数值：',arg)

funName() #调用方式一
funName('mark') #调用方式二 调用时传的参数会覆盖默认值

'''注释：
如果形参有默认值，调用时可以不需要传参，系统会直接使用参数的默认值。
调用时给有默认值的参数传参，实参会覆盖形参的默认值。本质上就是变量的重新赋值。
'''

使用关键字参数格式

函数名(形参1 = 实参1,形参2 = 实参2…)

示例：

#定义带有默认值参数的函数
def funName(name = 'jack',age = 18,sex = 'man'):
    print('name:',name)
    print('age:',age)
    print('sex:',sex)

funName(8,'二狗','Superman')
#参数较多时赋值顺序颠倒，将会影响程序执行结果
funName(age = 8,name = '二狗',sex = 'Superman')
#关键字参数赋值完美解决上面的问题

'''注释：
关键字参数就是调用函数时，在实参前面指定形参的
做法，为了防止参数按照位置传递出现的错误。
'''

多种参数混合使用应当注意：定义函数时尽量避免多种参数格式混合(普通参数，关键字参数，两种收集参数)
1.普通参数和关键字参数必须在两种收集参数之前
2.非关键字收集参数，必须在关键字收集参数之前
3.如果多种参数混合在一起用，必须注意禁止参数多次赋值操作(普通参数赋值在前，关键字参数赋值在后)

函数的返回值

根据执行函数完毕是否可以得到一个结果，我们可以将函数分为两种类型。

执行过程函数：
函数执行完毕之后，接收不到任何返回结果的函数。如：print()
具有返回值得函数：
函数执行完毕之后，会产生一个结果，可以被接收和使用的函数。如：type()

格式：

def 函数名(参数...):
    return 返回值 #有return的函数，就是有返回值的函数

变量名 = 函数名(参数...) #我们可以通过一个变量去接收函数的返回值

'''注释：
1.具有return语句的函数，我们称之为具有返回值的函数
2.return可以为当前函数执行完毕的函数返回一个结果，这个返回值可以用变量接收
3.return执行之后，函数将会终止，所以return之后的语句是不会被执行的
4.一个函数可以使用多个return语句，但是只有一个会被执行，一般都是放入分支结构中
5.一个函数如果需要返回多个数据，使用复合数据类型(list,tuple,set,dict)来操作即可
'''

函数文档

函数文档就是用来查看当前函数相关信息介绍的一个特定格式而已。

查看函数文档的方法

help(函数名)
此方法会直接输出函数文档的内容
函数名.__doc__
直接输出显示函数文档的内容元字符串(可以使用print(函数名.__doc__)来解决无格式问题)

定义函数文档的方法

def 函数名(参数):
'''
这里编写函数文档
'''
    这里编写函数的code...

示例：

#定义函数文档的方式
def funName(**car):
    '''
    这里是函数文档
    本函数功能是...
    要求的参数类型是...
    返回的数据是...
    '''
    print('函数文档的定义方法')

help(funName)
#查看函数文档

'''注释：
函数文档的作用是对函数进行说明，便于阅读和快速掌握函数的使用，通常函数文档需要具有以下信息：
1.函数的作用
2.函数的参数介绍(需要几个参数，分别是什么类型)
3.函数的返回值(数据和类型)
'''

变量的作用域

变量的作用域就是指变量的有效范围。
变量按照作用范围分为两类，分别是 全局变量 和 局部变量。

全局变量

在函数外部声明的变量就是全局变量

有效范围：
全局变量在函数外部可以正常使用。
全局变量在函数内部也可以正常使用(需要用global声明)

局部变量

在函数内部声明的变量就是局部变量

有效范围：
局部变量在函数内部可以正常使用
局部变量在函数外部不可以访问

Lambda表达式

lambda表达式是一种简洁格式的函数。该表达式不是正常的函数结构，而是属于表达式的类型。

基本格式

lambda 参数,参数…：函数功能代码
如：lambda x,y:x + y 获取2个值的和的lambda函数

带分支格式

lambda 参数,参数… :值1 if 条件表达式 else 值2
如：lambda sex : ‘有胡子’ if sex == ‘man’ else ‘没胡子’

调用函数格式

lambda 参数,参数…:其他函数(…)
如：lambda x:type(x)
lambda表达式的优缺点:

优点：
书写简单不需要def关键字
不需要费脑子想函数名(匿名函数)看起来高大上！

缺点：
lambda表达式功能受限，无法使用循环和多项分支
复杂的操作，不适合lambda表达式

示例:

#方式1.声明一个简单的lambda表达式
mylamb = lambda x,y:x+y
#调用函数
result = mylamb(4,5)
print(result)

#方式2.声明一个带有分支的lambda表达式
mylamb= lambda sex : '有胡子' if sex == 'man' else '没胡子'#调用函数
result = mylamb('woman')
print(result)

#方式3.声明一个调用函数的lambda表达式
mylamb = lambda x:type(x)
#调用函数
result = mylamb('拾元')
print(result)

类与对象

类的组成

对象 = 属性 + 方法

对象是类的实例。换句话说，类主要定义对象的结构，然后我们以类为模板创建对象。类不但包含方法定义，而且还包含所有实例共享的数据。

属性:
用于描述类的特征的变量就是成员属性

方法：
用于描述类的功能的函数就是成员方法

类的书写规则

1.必须使用class关键字来声明一个类
2.类的名称需要符合驼峰命名法（规范）
3.类中只能存在2种内容，成员属性和成员方法，除此之外，所有的代码都禁止出现！
4.声明成员属性时，所有成员属性必须有值，如果没值会报错！，推荐使用None等值代替
5.成员方法只需要按照函数的规则声明即可

共有和私有

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
定义在函数内部的变量拥有局部作用域，该变量称为局部变量。
定义在函数外部的变量拥有全局作用域，该变量称为全局变量。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

def discounts(price, rate):
    final_price = price * rate
    return final_price

old_price = float(input('请输入原价:'))  # 98
rate = float(input('请输入折扣率:'))  # 0.9
new_price = discounts(old_price, rate)
print('打折后价格是:%.2f' % new_price)  # 88.20

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal 关键字了。

num = 1

def fun1():
    global num  # 需要使用 global 关键字声明
    print(num)  # 1
    num = 123
    print(num)  # 123

fun1()
print(num)  # 123

继承

Python 同样支持类的继承。
如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性。

# 类定义
class people:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))


# 单继承示例
class student(people):
    grade = ''

    def __init__(self, n, a, w, g):
        # 调用父类的构函
        people.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))


s = student('小马的程序人生', 10, 60, 3)
s.speak()
# 小马的程序人生 说: 我 10 岁了，我在读 3 年级

注意：如果上面的程序去掉：people.__init__(self, n, a, w) ，则输出：说: 我 0 岁了，我在读 3 年级 ，因为子类的构造方法把父类的构造方法覆盖了。

魔法方法

魔术方法就是一个类/对象中的方法，和普通方法唯一的不同时，普通方法需要调用！而魔术方法是在特定时刻自动触发。

常用魔术方法

__init__

初始化魔术方法
触发时机：初始化对象时触发（不是实例化触发，但是和实例化在一个操作中）
参数：至少有一个self，接收对象
返回值：无
作用：初始化对象的成员
注意：使用该方式初始化的成员都是直接写入对象当中，类中无法具有

__del__

析构魔术方法
触发时机：当对象没有用（没有任何变量引用）的时候被触发
参数：一个self 结婚搜对象
返回值：无
作用：使用完对象是回收资源
注意：del不一定会触发当前方法，只有当前对象没有任何变量接收时才会触发

__call__

调用对象的魔术方法
触发时机:将对象当作函数调用时触发 对象()
参数:至少一个self接收对象，其余根据调用时参数决定
返回值：根据情况而定
作用：可以将复杂的步骤进行合并操作，减少调用的步骤，方便使用

__len__

触发时机：使用len(对象) 的时候触发
参数：一个参数self
返回值：必须是一个整型
作用：可以设置为检测对象成员个数，但是也可以进行其他任意操作
注意：返回值必须必须是整数，否则语法报错，另外该要求是格式要求。

__str__

触发时机:使用print(对象)或者str(对象)的时候触发
参数：一个self接收对象
返回值：必须是字符串类型
作用：print（对象时）进行操作，得到字符串，通常用于快捷操作

__format__

触发时机：使用字符串.format(对象)时候触发
参数：一个self接收对象，一个参数接收format的{}中的格式，例如:>5
返回值:必须是字符串
作用：设置对象可以作为format的参数，并且自定义对象格式化的规则

算数运算符

add(self, other) 定义加法的行为： +
sub(self, other) 定义减法的行为： -

class MyClass:
    def __init__(self, height, weight):
        self.height = height
        self.weight = weight
    # 两个对象的长相加，宽不变.返回一个新的类
    def __add__(self, others):
        return MyClass(self.height + others.height, self.weight + others.weight)
    # 两个对象的宽相减，长不变.返回一个新的类
    def __sub__(self, others):
        return MyClass(self.height - others.height, self.weight - others.weight)
    # 说一下自己的参数
    def intro(self):
        print("高为", self.height, " 重为", self.weight)
def main():
    a = MyClass(height=10, weight=5)
    a.intro()
    b = MyClass(height=20, weight=10)
    b.intro()
    c = b - a
    c.intro()
    d = a + b
    d.intro()
if __name__ == '__main__':
    main()
# 高为 10  重为 5
# 高为 20  重为 10
# 高为 10  重为 5
# 高为 30  重为 15

反算数运算符

反运算魔方方法，与算术运算符保持一一对应，不同之处就是反运算的魔法方法多了一个“r”。当文件左操作不支持相应的操作时被调用。

radd(self, other)
定义加法的行为： +
rsub(self, other) 定义减法的行为： -
rmul(self, other) 定义乘法的行为： *
rtruediv(self, other)定义真除法的行为： /
rfloordiv(self, other)定义整数除法的行为： //
rmod(self, other) 定义取模算法的行为： %
rdivmod(self, other) 定义当被 divmod() 调用时的行为
rpow(self, other[, module]) 定义当被 power() 调用或 ** 运算时的行为
rlshift(self, other) 定义按位左移位的行为： <<
rrshift(self, other) 定义按位右移位的行为： >>
rand(self, other) 定义按位与操作的行为： &
rxor(self, other) 定义按位异或操作的行为： ^
ror(self, other) 定义按位或操作的行为： |

一元运算符

neg(self)定义正号的行为： +x
pos(self)定义负号的行为： -x
abs(self)定义当被 abs() 调用时的行为
invert(self) 定义按位求反的行为： ~x