循环结构及函数基础

循环结构(for-in)

  • 简介

    • 说明:也是循环结构的一种,经常用于遍历字符串、列表、元组,字典等
    • 格式:
      1
      2
      for x in y:
      循环体

      执行流程:x依次表示y中的一个元素,遍历完所有元素循环结束

    • 示例1:遍历字符串
      1
      2
      3
      s = 'I love you more than i can say '
      for i in s:
      print(i)
    • 示例2:遍历列表
      1
      2
      3
      4
      5
      6
      7
      l = ['鹅鹅鹅', '曲项向天歌', '锄禾日当午', '春种一粒粟']
      for i in l:
      print(i)

      # 可以获取下标,enumerate每次循环可以得到下标及元素
      for i, v in enumerate(l):
      print(i, v)
    • 示例3:遍历字典
      1
      2
      3
      4
      5
      6
      7
      8
      9
      d = {'a': 'apple', 'b': 'banana', 'c': 'car', 'd': 'desk'}
      for key in d:
      # 遍历字典时遍历的是键
      print(key, d.get(key))

      # for key, value in d.items():
      #上下两种方式等价,d.items() <=> dict.items(d)
      for key, value in dict.items(d):
      print(key, value)
  • 列表生成式

    • 可迭代对象:列表、元组、字典等都是可迭代对象,就是可以遍历的对象
    • range:用法如下:
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      print(range(10))
      # 可以生成从0开始到10的连续整数的迭代对象
      print(range(0, 10))

      # 可以遍历
      for i in range(10):
      print(i)

      # 强制转换为列表
      print(list(range(1, 11)))
    • 列表生成式:快速生成具有特定规律的列表
      1
      2
      3
      4
      5
      6
      # 列表生成式
      print([i for i in range(1, 11)])
      print([i*2 for i in range(1, 11)])
      print([i*i for i in range(1, 11)])
      print([str(i) for i in range(1, 11)])
      print([i for i in range(1, 11) if i % 2 ==0])
  • 多重循环:就是循环中嵌套循环

    • 示例1:从终端输入一个整数,打印如下图形:
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      '''
      1
      1 2
      1 2 3
      1 2 3 4
      ...
      1 2 3 4 ... n
      '''

      n = int(input('请输入一个整数:'))
      for i in range(1, n+1):
      for j in range(1, i+1):
      print(j, end=' ')
      print()
    • 示例2:打印9x9乘法表
      1
      2
      3
      4
      5
      # 打印9x9乘法表
      for i in range(1, 10):
      for j in range(1, i+1):
      print('{}×{}={}'.format(j, i, j*i), end='\t')
      print()
    • 示例3:列表排序(选择排序)
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      l = [1, 9, 4, 2, 0, 8, 3, 7]

      # 获取列表的长度
      n = len(l)

      # 外层循环用来控制循环的圈数,每一圈可以确定一个元素的位置
      # 确定n个元素起始只需要n-1圈即可
      for i in range(n-1):
      # 内层循环用来比较大小交换元素,一圈确定一个元素
      for j in range(i+1, n):
      if l[i] > l[j]:
      # 交换两个变量
      l[j], l[i] = l[i], l[j]
      print(l)
    • 练习:
      1. 使用冒泡排序进行列表排序
        1
        2
        1. 冒泡排序:每次比较相邻的两个元素,不合适就交换,依次向后,一圈下来可以确定一个元素
        2. 需要使用双重循环,外层循环控制循环的圈数,内层控制一圈怎么交换
      2. 遍历列表,打印:我叫xxx,今年yyy岁,我来自zzz,数据如下
        1
        2
        3
        4
        5
        6
        7
        lt = [
        {'name': '小王', 'age': 18, 'info': [('phone', '123'), ('dizhi', '广州')]},
        {'name': '小芳', 'age': 19, 'info': [('phone', '789'), ('dizhi', '深圳')]},
        {'name': '小杜', 'age': 22, 'info': [('phone', '567'), ('dizhi', '北京')]},
        {'name': '小孟', 'age': 28, 'info': [('phone', '000'), ('dizhi', '上海')]},
        {'name': '小乔', 'age': 26, 'info': [('phone', '111'), ('dizhi', '河南')]},
        ]
      3. 从终端输入两个整数m,n,打印m*n的表格:如2,5,打印如下效果
        1
        2
        1 2 3 4 5
        6 7 8 9 10

函数

  • 定义

    • 具有特定功能的一段代码
  • 优点

    • 为了解决代码的重复书写问题
    • 可以将功能的实现者和使用者分开,提高开发效率
    • 增加代码的可移植性
  • 分类

    • 库函数:
      • print、input、abs等
    • 自定义:用户自己封装的函数
  • 格式

    1
    2
    def 函数名([参数列表]):
    函数体

    [] 表示可选,参数可以没有,也可以有多个。

  • 函数名

    • 遵循标识符的命名规范(与变量名相同)
  • 函数调用

    • 函数定义以后不会执行,需要调用才执行
    • 调用:函数名([参数])
  • 示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    # 无参无返回值
    def print_hello():
    print('Hello')
    # print_hello()

    # 带参无返回值
    def print_n_hello(n):
    for i in range(n):
    print('Hello')
    # print_n_hello(5)

    # 带参有返回值
    def add(m, n):
    # 返回结果
    return m + n
    print(add(3, 5))
  • 函数参数

    • 形参:形式参数,函数定义处的参数
    • 实参:实际参数,函数调用处的参数
    • 必传参数:也叫位置参数,前面定义的函数中都是必传参数,调用时的形式必须要与定义的一致。
    • 默认参数:就是有默认值的参数,必须放到最后
    • 可变长度参数:函数调用时传递的参数比定义时的参数要多,多出来的参数后保存在args和kwargs中
    • 示例1
      1
      2
      3
      4
      5
      6
      7
      8
      9
      def show(a, b='默认值'):
      # a就是必传参数
      print(a)
      # b就是默认参数,就是有默认值的参数,必须放在最后
      print(b)

      # show(1, 2)
      # 关键字参数,传递参数的时候指定了名字,顺序就无所谓了
      show(b=456, a=123)
    • 示例2
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      def var_len_args(a, b, name='默认名称', *args, **kwargs):
      print(a)
      print(b)
      print(name)
      # args是一个元组,用来存放所有的多出来的位置参数
      print(args)
      # kwargs是一个字典,用来存放所有的多出来的默认参数
      print(kwargs)


      var_len_args(1, 2, 3, 4, 5, age=18)
  • *的特殊用法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    def show(a, b):
    print(a, b)

    l = [1, 2]
    # 略显啰嗦
    # show(l[0], l[1])
    # 精简方法
    # show(*l)

    def show2(a='aa', b='bb'):
    print(a, b)
    d = {'a':'apple', 'b':'banana'}

    # show2(a=d['a'], b=d['b'])
    # 上面方式的简单书写
    show2(**d)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    tu = (1, 2, 3, 4, 5)


    def qiuji(length, args):
    ji = 1
    for i in range(length):
    ji *= args[i]
    return ji


    def calc(func, *args):
    print(args)
    return func(len(args), args)


    print(calc(qiuji, *tu))
  • 练习:

    1
    2
    1.前面所有的练习,能用函数的封装成函数
    2.封装函数:生成随机的字符串,参数:长度(默认为4),类型(默认为0)