2022年 11月 9日

Python 函数及类


系列文章:


文章目录

  • 函数
    • 参数传递
      • 1.位置参数
      • 2. 关键字参数
      • 3.默认参数
      • 4.让参数变成可选的
      • 5.可变长参数 \*args
      • 6.可变长参数 \*\*kwargs
    • 变量作用域
    • 返回值
    • 命名建议
    • 类的定义
    • 类的实例
    • 类的继承

函数

函数定义及调用
定义

def 函数名(参数):
  函数体
  return 返回值

调用
函数名(参数)

参数传递

1.位置参数

  • 严格按照位置顺序,用实参对形参进行赋值
  • 一般在参数比较少的时候
def fun(x, y, z):
    print(x, y, z)
fun(1, 2, 3)
  • 1
  • 2
  • 3

2. 关键字参数

  • 打破位置限制,直呼其名的对值的传递(形参=实参)
  • 必须遵守实参与形参数数量上一一对应
  • 多用在参数比较多的场合
def fun(x, y, z):
    print(x, y, z)
fun(y=1, z=2, x=3) #3 1 2
  • 1
  • 2
  • 3
  • 位置参数和关键字参数混合使用
  • 但是 位置参数必须放在关键字参数前面
def fun(x, y, z):
    print(x, y, z)
fun(1, z=2, y=3)
  • 1
  • 2
  • 3
def fun(x, y, z):
    print(x, y, z)
fun(1, 2, z=3)
  • 1
  • 2
  • 3

3.默认参数

  • 定义阶段就给形参赋值—该形参的常用值
  • 默认参数必须放在非默认参数后面
  • 调用函数时,可以不对该形参传值
def register(name, age, sex="male"):
    print(name, age, sex)
register("大杰仔", 18)
  • 1
  • 2
  • 3

也可以按正常的形参进行传值

register("林志玲", 38, "female")
  • 1

默认参数应该设置为不可变类型(数字、元组、字符串)

def fun(ls=[]):
    print(id(ls))
    ls.append(1)
    print(id(ls))
    print(ls)
fun()
fun()
fun()
当参数数可变类型:每次调用所用的list是同一个:
1608045904832
1608045904832
[1]
1608045904832
1608045904832
[1, 1]
1608045904832
1608045904832
[1, 1, 1]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

4.让参数变成可选的

def name(first_name, last_name, middle_name=None):
    if middle_name:
        return first_name + middle_name + last_name
    else:
        return first_name + last_name
print(name("大","仔"))
print(name("大", "仔", "杰"))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

5.可变长参数 *args

  • 不知道 会传来多少参数 *args
  • 该形参必须放在参数列表的最后
def foo(x, y,z, *args):
    print(x ,y , z,args)

foo(1,2,3,4,5,6,{"hh"})   # 1 2 3 (4, 5, 6, {'hh'}) 多余的参数,打包传递给args
foo(1,2,3,[4,5,6],{"HH"}) # 1 2 3 ([4, 5, 6], {'HH'})
# 带* 的列表、字符串、元组或者集合内的元素打散
foo(1,2,3,*[4,5,6],*{"hh"}) # 1 2 3 (4, 5, 6, 'hh') 打散的是列表、字符串、元组或集合
foo(1,2,3,*[4,5,6],{"hh"}) # 1  2 3 (4, 5, 6, {'hh'})
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

6.可变长参数 **kwargs

def foo(x, y,z, **kwargs):
    print(x ,y , z,kwargs)
    
# 多余的参数,以字典的形式打包传递给kwargs
foo(1,2,3,a=4,b=5,c=6,d={"hh"})   
#1 2 3 {'a': 4, 'b': 5, 'c': 6, 'd': {'hh'}} 


foo(1,2,3,a=4,b=5,c=6,**{"h":"H","m":"m"},**{"N":"N","K":"K"}) 
#1 2 3 {'a': 4, 'b': 5, 'c': 6, 'h': 'H', 'm': 'm', 'N': 'N', 'K': 'K'}

foo(1,2,3,**{"a": 4, "b": 5, "c":6,"d":"hh"})
# 1 2 3 {'a': 4, 'b': 5, 'c': 6, 'd': 'hh'}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 可变长参数的组合使用
def foo(*args, **kwargs):
    print(args)
    print(kwargs)

foo(1,2,3,a=4,b=5,c=6)
# (1, 2, 3)
# {'a': 4, 'b': 5, 'c': 6}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

变量作用域

  • 局部变量:仅在函数体内定义和发挥作用
  • 全局变量-外部定义的都是全局变量
  • 全局变量可以在函数体内直接使用
  • 通过global在函数体内定义全局变量
def multipy(x, y):
    global z
    z = x*y
    return z 
print(multipy(2, 9))
print(z)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

返回值

  • 单个返回值
  • 多个返回值—-以元组的形式
def foo(x):
    return 1, x, x**2, x**3    # 逗号分开,打包返回
a, b , c, d = foo(3)       # 解包赋值
  • 1
  • 2
  • 3
  • 可以有多个return语句,一旦其中一个执行,代表了函数运行的结束
  • 没有return 语句,返回值为None
def foo():
    print("我是孙悟空")

res = foo()
print(res)
  • 1
  • 2
  • 3
  • 4
  • 5

命名建议

1、函数及其参数的命名参考变量命名

  • 字母小写及下划线组合

2、应包含简要阐述函数功能的注释,注释紧跟函数定义后面

def foo():
    # 这个函数的作用是为了给大家瞅一瞅,你瞅啥,瞅你咋地。。。。
    pass
  • 1
  • 2
  • 3

3、函数定义前后各空两行

def f1():
    pass

                 # 空出两行,以示清白
  • 1
  • 2
  • 3
  • 4

4、默认参数赋值等号两侧不需加空格

def f3(x=3):    # 默认参数赋值等号两侧不需加空格
    pass
  • 1
  • 2

类的定义

1、类-命名规范
驼峰命名法:组成的单词首字母大写
Dog、 CreditCard、 ElectricCar

# class 类名:
"""类前空两行"""


class Car():
    """对该类的简单介绍"""
    pass

"""类后空两行"""
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

2、类的属性

# def __init__(self,要传递的参数)  初始化类的属性
  • 1
class Car():
    """模拟汽车"""
    
    def __init__(self, brand, model, year):
        """初始化汽车属性"""               # 相当于类内部的变量
        self.brand = brand                 # 汽车的品牌
        self.model = model                 # 汽车的型号
        self.year = year                   # 汽车出厂年份
        self.mileage = 0                   # 新车总里程初始化为0   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

3、类的方法

class Car():
    """模拟汽车"""
    
    def __init__(self, brand, model, year):
        """初始化汽车属性"""               # 相当于类内部的变量
        self.brand = brand                 # 汽车的品牌
        self.model = model                 # 汽车的型号
        self.year = year                   # 汽车出厂年份
        self.mileage = 0                   # 新车总里程初始化为0  
        
    def get_main_information(self):        # self不能省
        """获取汽车主要信息"""
        print("品牌:{}   型号:{}   出厂年份:{}".format(self.brand, self.model, self.year))
    
    def get_mileage(self):
        """获取总里程"""
        return "行车总里程:{}公里".format(self.mileage)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

类的实例

1、实例的创建
v = 类名(必要的初始化参数)

my_new_car = Car("Audi", "A6", 2018)
  • 1

2、访问属性
实例名.属性名

3、调用方法
实例名.方法名(必要的参数)

4、修改属性
直接修改 my_old_car = Car(“BYD”, “宋”, 2016)
先访问后修改 my_old_car.mileage = 12000
通过方法修改 my_old_car.set_mileage(8000)

类的继承

继承方式 class 子类名(父类名):

class ElectricCar(Car):
    def __init__(self,brand, model, year, bettery_size):
        """初始化电动汽车属性"""
        super().__init__(brand,model,year) #声明继承父类的属性
        self.bettery_size = bettery_size  #电池容量
        self.electric_quantity = bettery_size #电池剩余量
        self.electric2distance_ratio = 5  # 电量距离换算系数 5公里/kW.h
        self.remainder_range = self.electric_quantity * self.electric2distance_ratio  # 剩余可行驶里程

    def get_electric_quantit(self):
        """查看当前电池电量"""
        print("当前电池剩余电量:{} kW.h".format(self.electric_quantity))

    def get_main_infomation(self): #重写父类方法
        """获取汽车主要信息"""
        pass


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18