Python 基础学习笔记 03

Python基础系列
Python 基础学习笔记 01
Python 基础学习笔记 02
Python 基础学习笔记 03
Python 基础学习笔记 04
Python 基础学习笔记 05

4.1. 判断语句

• 语法格式：

  if 要判断的条件:
  	条件成立时,要做的事情
  else
  	条件不成立时，要做的事情
  

---

4.2. 逻辑运算

• 在程序开发中，通常在判断条件时，会需要同时判断多个条件
• 只有多个条件都满足，才能够执行后续代码，这时需要使用到逻辑运算符
• 逻辑运算符可以把多个条件按照逻辑进行连接，变成再复杂的条件
• Python中的逻辑运算符包括：与and/或or/非not三种

4.2.1. and

• 格式：

  条件1 and 条件2
  

• 真假表
  

4.2.2. or

• 格式：

  条件1 or 条件2
  

• 真假表

4.2.3. not

• 格式：

  not 条件
  

• 真假表

---

4.3. if语句进阶

4.3.1. elif

• 在开发中，使用if可以判断条件，使用else可以处理条件不成立的情况，但是，如果希望再增加一些条件，条件不同，需要执行的代码也不同时，就可以使用elif

• 语法格式：

  if 条件1：
  	条件1满足执行的代码
  elif 条件2：
  	条件2满足时，执行的代码
  elif 条件3：
  	条件3满足时，执行的代码
  else:
  	以上条件都不满足时，执行的代码
  

• 注意：

  1. elif和else都必须和if联合使用，而不能单独使用
  2. 可以将if、elif和else以及各自缩进的代码，看成一个完整的代码块

4.3.2. if 的嵌套

• 在开发时，使用if进行条件判断，如果希望再条件成立执行语句中再增加条件判断，就可以使用if的嵌套。if嵌套使用的场景就是：在之前条件满足的前提下，再增加额外的判断，注意缩进

• 语法格式：

  if 条件1：
  # 条件1满足执行的代码
  	if 条件1基础上的条件2：
  		条件2满足时，执行的代码
  	# 条件2不满足的处理
  	else:
  		条件2不满足时，执行的代码
  # 条件1不满足的处理
  else:
  	条件1不满足时，执行的代码
  

---

4.4. 运算符

4.4.1. 算数运算符

• 是完成基本的算术运算使用的符号，用来处理四则运算
  

4.4.2. 关系运算符

4.4.3. 逻辑运算符

4.4.4. 赋值运算符

4.4.5. 运算符的优先级

---

4.5. 循环

• 语法：

  初始条件设置--通常是重复执行的计数器
  
  while条件（判断 计数器 是否达到 目标次数）：
  	条件满足时，做的事情1
  	条件满足时，做的事情2
  	条件满足时，做的事情3
  	..(省略).
  	处理条件（计数器+1）
  

• break和continue

  • break：某一条件满足时，退出循环，不再执行后续重复的代码
  • continue：某一条件满足时，不执行后续重复的代码
  • break和continue只针对当前所在循环有效

• 循环嵌套

  语法：

  while 条件 1：
  	条件满足时，做的事情1
  	条件满足时，做的事情2
  	条件满足时，做的事情3
    
  	while 条件 2：
  		条件满足时，做的事情1
  		条件满足时，做的事情2
  		条件满足时，做的事情3
  		..(省略).
  		处理条件2
     
  	处理条件1
  

---

4.6. 转义字符

---

4.7. 函数

• 函数：把具有独立功能的代码块组织成一个小模块，在需要的时候调用

• 步骤：

  1. 定义函数 封装独立的功能
  2. 调用函数 享受封装的结果

• 作用：在程序开发时，使用函数可以提高编写的效率以及代码的重用

• 语法：

  def 函数名():
  	函数封装的代码
  

• 函数名称应该能够表达函数封装代码的功能，方便后续的调用

• 函数名称的命名应该符合表示符的命名规则

---

4.8. 调试工具

• F8 Step Over可以单步执行代码，会把函数调用看作是一行代码直接执行
• F7 Step Into可以单步执行代码，如果是函数，会进入函数内部

---

4.9.函数的文档注释

• 在开发中，如果希望给函数添加注释，应该在定义函数的下方，使用连续的三对引号
• 在连续的三对引号之间编写对函数的说明文字
• 在函数调用位置，使用快捷键CTRL+Q可以查看函数的说明信息

---

4.10. 函数的参数

• 函数的参数，增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据
• 在函数内部，把参数当做变量使用，进行需要的数据处理
• 函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递

---

4.11. 形参和实参

• 形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用
• 实参：调用函数时，小括号中的参数，是用来把数据传递到函数内部用的

---

4.12. 函数的返回值

• 在程序开发中，有时候会希望一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
• 返回值是函数完成工作后，最后给调用者的一个结果
• 在函数中使用return关键字可以返回结果
• 调用函数的一方，可以使用变量来接收函数的返回结果

---

4.13. 使用模块中的函数

• 模块：模块就好比工具包，要想使用这个工具包中的工具，就需要导入import这个模块。每一个以拓展名py结尾的python源代码文件都是一个模块。在模块中定义的全局变量、函数都是模块能够提供给外界直接使用的工具。

---

4.14. Pyc文件

• 操作步骤
  1. 浏览程序目录会发现__pycache__的目录
  2. 目录下会有一个hm_10_分隔线模块.cpython-39.pyc文件，cpython-39表示python解释器的版本
  3. 这个pyc文件是由python解释器将模块的源码转换为字节码
     • python这样保存字节码是作为一种启动速度的优化
• 字节码
  • python在解释源程序时是分成两个步骤的
    1. 首先处理源代码，编译生成一个二进制字节码
    2. 再对字节码进行处理，才会生成CPU能够识别的机器码
  • 有了模块的字节码以后，下次运行程序时，如果在上次保存字节码之后没有修改过源代码，python将加载.pyc文件并跳过编译这个步骤
  • 当python重编译时，它会自动检查源文件和字节码文件的时间戳
  • 如果你又修改了源代码，下次程序运行时，字节码将自动重新创建

---

4.15. 非数字型变量的特点

• 特点：
  1. 都是一个序列，也可以理解为容器
  2. 取值[]
  3. 遍历 for in
  4. 计算长度、最大/最小值、比较、删除
  5. 链接+和重复*
  6. 切片

---

4.16. 列表

4.16.1. 列表的定义

• 定义：List(列表)是python中使用最频繁的数据类型，专门用于存储一串信息。列表用[]定义，数据之间使用,隔开。列表的索引从0开始，索引就是数据在列表中的位置编号，索引又可以称为下标。从列表中取值时，如果超出索引范围，程序会报错。

4.16.2. 列表的常用操作

• 具体代码：

  namelist = ["zhangsan","wangwu","lisi","wangwu"]
  
  # 1.取值或取索引
  print(namelist[2])
  # 求取列表内容所在的位置  (ValueError: 'wangwu321' is not in list)
  print(namelist.index("wangwu"))
  
  
  # 2.修改   (IndexError: list assignment index out of range)
  print(namelist)
  namelist[1] = "李四"
  print(namelist)
  
  
  # 3.增加
  # append可以向列表的末尾追加数据
  namelist.append("王小二")
  print(namelist)
  #insert可以向列表的指定位置插入数据
  namelist.insert(1,"小美眉")
  print(namelist)
  # extend可以把其他列表的完整内容，追加到当前列表的末尾
  temp_list = ["孙悟空","猪二哥","沙师弟"]
  namelist.extend(temp_list)
  print(namelist)
  
  
  # 4.统计
  print(len(namelist))
  
  
  # 5.排序
  print(namelist)
  namelist.sort()
  print(namelist)
  namelist.sort(reverse=True)
  print(namelist)
  namelist.reverse()
  print(namelist)
  
  
  # 6.删除
  # remove可以从列表中删除指定的数据
  namelist.remove("wangwu")
  print(namelist)
  # pop可以删除列表最后的数据
  namelist.pop()
  print(namelist)
  namelist.pop(3)
  print(namelist)
  # clear可以清空整个列表
  namelist.clear()
  print(namelist)
  

• del关键字

  • 使用del关键字同样可以删除列表中元素
  • del关键字本质上是用来将一个变量从内存中删除的
  • 如果使用del关键字将变量从内存中删除，后续的代码就不能再使用这个变量

  del name_list[1]
  

  在日常开发中，要从列表删除数据，建议使用列表提供的方法

4.16.3. 循环遍历

• 遍历就是从头到尾依次从列表中获取数据，在循环体内部针对每一个元素，执行相同的操作

• 在python中为了提高列表的遍历效率，专门提供了迭代iteration遍历

• 使用for就能够实现迭代遍历

  # for 循环内部使用的变量 in 列表
  for name in name_list:
  	循环内部针对列表元素进行操作
  	print(name)
  

• 具体代码：

  name_list = ["张三","李四","王五","王小二"]
  
  for my_name in name_list:
    print("我的名字叫 %S" % my_name)
  

4.16.4. 应用场景

• 场景：
  1. 列表存储相同类型的数据
  2. 通过迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作

---

4.17. 元组

4.17.1. 元组的定义

• Tuple(元组)与列表类似，不同之处在于元组的元素不能修改
  • 元组表示多个元素组成的序列
  • 元组在python开发中，有特定的应用场景
• 用于存储一串信息，数据之间使用,分隔
• 元组用()定义
• 元组的索引从0开始，索引就是数据在元组中的位置编号

4.17.2. 元组的创建

info_tuple = ()

元组中只包含一个元素时，需要在元素后面添加逗号

info_tuple = (50,)

4.17.3. 元组的常用操作

• 具体代码：

  # 1.从列表中取值
  info_tuple = ("zhangsan",18,1.75,"zhangsan")
  print(info_tuple[2])
  
  # 2.取索引(第一次)，已知数据的内容，希望知道该数据在元组中的索引
  print(info_tuple.index("zhangsan"))
  
  # 3.统计元组中包含元素的个数
  print(len(info_tuple))
  
  # 4.统计计数
  print(info_tuple.count("zhangsan"))
  

4.17.4. 循环遍历

• 取值就是从元组中获取存储在指定位置的数据

• 遍历就是从头到尾依次从元组中获取数据

• 注意：

  • 在python中，可以使用for循环遍历所有非数字型的变量：列表、元组、字典以及字符串

• 具体代码：

  info_tuple = ("zhangsan",18,1.75)
  
  for my_info in info_tuple:
      print(my_info)
  

4.17.5. 应用场景

• 函数的参数和返回值，一个函数可以接收任意多个参数，或者一次返回多个数据

• 格式字符串，格式化字符串后面的()本质上就是一个元组

  info_tuple = ("zhangsan",18,1.75)
  
  print("%s 的年龄是 %d ,身高是 %.2f" % info_tuple)
  

• 让列表不可以被修改，以保护数据安全

4.17.6. 元素和列表之间的转换

• 使用list函数可以把元组转换成列表

  # 定义元组
  num_tuple = (1,2,3,4)
  
  # 使用list函数可以把元组转换成列表
  num_list = list(num_tuple)
  print(type(num_list))
  

• 使用tuple函数可以把列表转换成元组

  # 定义列表
  num_list = [1,2,3,4]
  
  # 使用tuple函数可以把列表转换成元组
  num_tuple = tuple(num_list)
  print(type(num_tuple))
  

---

4.18. 字典

4.18.1. 字典的定义

• 字典同样可以存储多个数据，通常用于存储描述一个物体的相关信息
• 和列表的区别
  • 列表是有序的对象集合
  • 字典是无序的对象集合
• 字典使用{}定义
• 字典使用键值对存储数据，键值对之间使用,分隔
  • 键key是索引，必须是唯一的
  • 值value是数据，可以取任何数据类型，但键只能使用字符串、数字和元组
  • 键和值之间使用:分隔

4.18.2. 字典常用操作

• 具体代码

  # 1.字典的定义
  xiaoming_dict = {"name":"xiaoming",
              "age":18,
              "gender":True,
              "height":1.75,
              "weight":75}
  print(xiaoming)
  
  # 2.取值 (KeyError: 'name123')
  print(xiaoming_dict["name"])
  print(xiaoming_dict.get("age"))
  
  # 3.增加或修改数据
  # key不存在，增加数据
  xiaoming_dict["age"] = 17
  # key存在，修改数据
  xiaoming_dict["name"] = "小小明"
  # key存在，不修改数据
  xiaoming_dict.setdefault("name","大明")
  # key不存在，增加数据
  xiaoming_dict.setdefault("hobby","篮球")
  
  # 4.删除数据
  # 删除指定键值对
  xiaoming_dict.pop("name")
  #随机删除一个键值对(??最后一个，不随机??)
  xiaoming_dict.popitem()
  # 清空字典
  xiaoming_dict.clear()
  
  # 5.统计键值对数量
  print(len(xiaoming_dict))
  
  # 6.合并字典
  # 如果被合并的字典中包含已经存在的键值对，会覆盖原有的键值对
  temp_dict = {"height":1.75,"age":20}
  xiaoming_dict.update(temp_dict)
  
  # 7.获取所有key列表
  keys = xiaoming_dict.keys()
  print(keys)
  
  # 8.获取所有value列表
  xiaoming_dict.values()
  

4.18.3. 循环遍历

• 遍历：依次获取所有键值对

  # for 循环内部使用的 key的变量 in 字典
  for k in xiaoming_dict:
    print("%s: %s" % (k,xiaoming_dict[k]))
  

  注意：在实际开发中，由于字典中的每一个键值对保存数据的类型是不同的，所以针对字典的循环遍历需求不是很多

4.18.4. 应用场景

• 使用多个键值对，存储描述一个物体的相关信息–描述更复杂的数据信息

• 将多个字典放在一个列表中，再进行遍历，在循环体内部针对每一个字典进行相同的处理

  card_list = [
      {"name":"张三",
       "qq":"12345",
       "phone":"110"
       },
      {"name": "李四",
       "qq": "54321",
       "phone": "10086"
       }
  ]
  
  for card_info in card_list:
      print(card_info)
  

---

4.19. 字符串

4.19.1. 字符串的定义

• 字符串就是一串字符，是编程语言中表示文本的数据类型

• 在python中可以使用一对双引号"或者一对单引号'定义一个字符串

• 如果字符串内部需要使用"，可以使用'定义字符串

• 如果字符串内部需要使用'，可以使用"定义字符串

• 可以使用索引获取一个字符串中指定位置的字符，索引计数从0开始

• 也可以使用for循环遍历字符串中每一个字符

• 定义与遍历

  str1 = "hello python"
  str2 = "我的外号是'大西瓜'"
  
  for char in str2:
      print(char)
  

4.19.2. 字符串的常用操作

• 判断类型 - 9
  

  # 1.判断空白字符
  space_str = "    \r\t\n"
  print(space_str.isspace())
  
  # 2.判断字符串中是否只包含数字
  num_str = "12\u00b2"
  
  # 只能判断单纯数字
  print(num_str.isdecimal())
  # 可以判断数字和unicode编码
  print(num_str.isdigit())
  # 可以判断字母、unicode、中文数字
  print(num_str.isnumeric())
  

• 查找和替换 - 7
  

  hello_str = "hello world"
  
  
  # 1.判断是否以指定字符串开始
  print(hello_str.startswith("hello"))
  
  # 2.判断是否以指定的字符串结束
  print(hello_str.endswith("world"))
  
  # 3.查找指定字符串
  # index同样可以查找指定的字符串在大字符串中的索引
  print(hello_str.find("llo"))
  # index如果指定的字符串不存在，会报错
  # find如果指定的字符串不存在，会返回-1
  print(hello_str.find("abc"))
  
  # 4.替换字符串
  # replace方法执行完成以后，会返回一个新的字符串
  # 注意：不会修改原有字符串的内容
  print(hello_str.replace("world","python"))
  print(hello_str)
  

• 大小写转换 - 5
  

  hello_str = "hello world"
  
  # 把字符串中的第一个字符大写
  print(hello_str.capitalize())
  # 把字符串中的每个单词首字母大写
  print(hello_str.title())
  # 转换hello_str的小写字母为大写字母
  print(hello_str.upper())
  

• 文本对齐 - 3
  

  # 要求：顺序并居中对齐输出以下内容
  poem = ["登鹳雀楼\n\t",
          "王之涣",
          "白日依山尽",
          "\t黄河入海流",
          "欲穷千里目",
          "更上一层楼"]
  
  
  for poem_str in poem:
      # 先使用strip方法去除字符串中的空白字符
      # 再使用center方法居中显示文本
  
      print("|%s|" % poem_str.strip().center(20," "))
  
  

• 去除空白字符 - 3
  

• 拆分和连接 - 5
  

  # 以anhui为基础进行分割，分割成三个元组
  # 把数据转换成元组，使用循环输出结果
  helllo_str = "helloanhuiaust"
  hello_tuple = helllo_str.partition("anhui")
  
  for mytuple in hello_tuple:
      print(mytuple,len(mytuple))
  

  # 1.将字符串中的空白字符全部去掉
  # 2.再使用" "作为分隔符，拼接成一个整齐的字符串
  
  poem_str = "登鹳雀楼\n\t王之涣\n白日依山尽\t黄河入海流\t\n欲穷千里目\t\n更上一层楼"
  print(poem_str)
  
  # 1.拆分字符串 split函数的返回值是字符串列表
  poem_list = poem_str.split()
  print(poem_list)
  
  # 2.合并字符串
  result = " ".join(poem_list)
  print(result)
  

4.19.3. 字符串的切片

• 切片方法适用于字符串、列表、元组

  • 切片使用索引值来限定范围，从一个大的字符串中切出小的字符串
  • 列表和元组都是有序的集合，都能够通过索引值获取到对应的数据
  • 字典是一个无序的集合，是使用键值对保存数据

• 操作：

  字符串[开始索引:结束索引:步长]
  

• 注意：

  1. 指定的区间属于左闭右开型[开始索引，结束索引)，从起始位置开始，到结束位置的前一位结束
  2. 从头开始，开始索引数字可以省略，冒号不能省略
  3. 到末尾结束，结束索引数字可以省略，冒号不能省略
  4. 步长默认为1，如果连续切片，数字和冒号都可以省略

• 索引的顺序和倒序

  • 倒序索引时，最右边的索引值是-1，依次递减

• 具体代码：

  num_str = "0123456789"
  
  # 1.截取2-5位置的字符串(左闭右开)
  print(num_str[2:6])
  
  # 2.截取2-末尾位置的字符串(末尾可以省略)
  print(num_str[2:])
  
  # 3.截取从开始-5的字符串(开始可以省略)
  print(num_str[:6])
  
  # 4.截取完整的字符串(开始和结束都省略)
  print(num_str[:])
  
  # 5.从开始位置开始，每隔一个字符截取一个字符
  print(num_str[::2])
  
  # 6.从索引1开始，每隔一个字符取一个字符
  print(num_str[1::2])
  
  # 7.倒序切片 -1表示倒数第一个字符
  print(num_str[-1])
  
  # 8.截取从2-末尾-1的字符串
  print(num_str[2:-1])
  
  # 9.截取字符串末尾的两个字符
  print(num_str[-2:])
  
  # 10.字符串的逆序
  print(num_str[::-1])
  

---

4.20. 公共方法

• Python内置函数
  

• 切片

  • 切片使用索引值来限定范围，从一个大的字符串中切出小的字符串
  • 列表和元组都是有序的集合，都能够通过索引值获取到对应的数据
  • 字典是一个无序的集合，是使用键值对保存数据

• 运算符
  

  • 具体代码：

    # 合并 +
    list1 = [1,2,3]
    list2 = [4,5,6]
    print(list1+list2)
    
    # 重复 *
    str1 = ["Hi"]
    print(str1 * 4)
    
    # 元素是否存在与不存在
    tuple1 = (1,2,3,4)
    print(2 in tuple1)
    print(5 not in tuple1)
    
    # 元素比较
    print((4,5,6) < (2,))
    

• 完整的for循环语法

  • 语法：

    for 变量 in 集合:
      循环体代码
    else:
      没有通过 break 退出循环，循环结束后，会执行的代码
    

  • 具体实现代码：

    # 在学员列表中搜索指定的姓名
    find_name = "张三"
    
    students = [
        {"name":"阿土",
        "age":20,
        "gender":True,
        "height":1.7,
        "weight":75.0},
        {"name":"小美",
        "age":19,
        "gender":False,
        "height":1.6,
        "weight":45.0},
        ]
    
    for stu_dict in students:
        print(stu_dict)
    
        if stu_dict["name"] == find_name:
            print("找到了 %s" % find_name)
            # 如果找到直接退出循环，后续不在遍历
            break
    else:
        # 如果希望在搜索列表时，所有的字典检查之后，都没有需要搜索的目标
        print("没有找到 %s " % find_name)
    
    print("循环结束")
    

---

4.21. 变量进阶

4.21.1. 变量的引用

• 引用：变量和数据是分开存储的，数据保存在内存中的一个位置，变量中保存着数据在内存中的地址，变量中记录数据的地址，就叫做引用，使用id()函数可以查看变量中保存数据素在的内存地址。
• 函数的参数和返回值的传递：通过引用来传递

4.21.2. 可变和不可变类型

• 不可变类型，内存中的数据不允许被修改：
  • 数字类型 int,bool,float,complex,long(2.x)
  • 字符串str
  • 元组tuple
• 可变类型，内存中的数据可以被修改：
  • 列表list
  • 字典dict

4.21.3. 局部变量和全局变量

• 局部变量是在函数内部定义的变量，只能在函数的内部使用

• 全局变量是在函数外部定义的变量，所有函数内部都可以使用这个变量

• 局部变量

  • 局部变量是在函数内部定义的变量，只能在函数内部使用

  • 函数执行结束后，函数内部的局部变量，会被系统回收

  • 不同的函数，可以定义相同的名字的局部变量，而且彼此之间不会产生影响

  • 作用：

    • 在函数内部使用，临时保存函数内部需要使用的数据

  • 生命周期：

    • 所谓生命周期就是从变量被创建到被系统回收的过程
    • 局部变量在函数执行时才会被创建
    • 函数执行结束后局部变量被系统回收
    • 局部变量在生命周期内，可以用来存储函数内部临时使用的数据

  • 代码实现：

    def demo1():
      	# 局部变量
        num = 10
        print("在demo1内部的变量是%d" % num)
    
    demo1()
    

• 全局变量

  • 全局变量是在函数外部定义的变量，所有函数内部都可以使用这个变量

  • 函数执行时，需要处理变量时：

    1. 首先查找函数内部是否存在指定名称的局部变量，如果有，直接使用
    2. 如果没有，查找函数外部是否存在指定名称的全局变量，如果有，直接使用
    3. 如果还没有，程序报错

  • 代码实现：

    # 全局变量
    num = 10
    
    def demo1():
        print("demo1 ==> %d" % num)
    
    def demo2():
        print("demo2 ==> %d" % num)
    
    demo1()
    demo2()
    

  • 函数不能直接修改全局变量的引用

    num = 10
    
    def demo1():
        # 希望修改全局变量的值
        # 在python中，是不允许直接修改全局变量的值，如果使用赋值语句，会在函数内部定义		   一个局部变量
        num = 99
        print("demo1 ==> %d" % num)
    
    def demo2():
        print("demo2 ==> %d" % num)
    
    demo1()
    demo2()
    print(num)
    

  • 在函数内部修改全局变量的值

    • 在函数中需要修改全局变量的值，需要使用global进行声明

      num = 10
      
      def demo1():
      		# global声明全局变量的值
          global num
          num = 99
          print("demo1 ==> %d" % num)
      
      def demo2():
          print("demo2 ==> %d" % num)
      
      demo1()
      demo2()
      print(num)
      

  • 全局变量定义的位置

    • 为了保证所有函数都能正确使用全局变量，应该将全局变量定义在其他函数的上方

      # 全局变量的位置
      num = 10
      title = "黑马程序员"
      name = "小明"
      
      
      def demo():
          print("%d" % num)
          print("%s" % title)
          print("%s" % name)
      
      def demo2():
          print("%s" % name)
      
      demo()
      demo2()
      

    • 代码结构示意图
      

  • 全局变量命名的建议

    • 为了避免局部变量和全局变量出现混淆，在定义全局变量时，有些公司会有一些开发要求，比如在全局变量名前增加g_或者gl_的前缀

---

4.22. 函数进阶

4.22.1. 函数参数和返回值的作用

• 无参数，无返回值
  • 应用场景：
    1. 只是单纯的做一件事，例如显示菜单
    2. 在函数内部针对全局变量进行操作，例如：新建名片，最终结果记录在全局变量中
  • 注意：
    • 如果全局变量的数据类型是一个可变类型，在函数内部可以使用方法修改全局变量的内容，变量的引用不会改变
    • 在函数内部，使用赋值语句才会修改变量的引用
• 无参数，有返回值
  • 应用场景：
    • 采集数据，例如温度计，返回结果就是当前的温度，而不需要传递任何的参数
• 有参数，无返回值
  • 应用场景：
    • 函数内部代码保持不变，针对不同的参数处理不同的数据
• 有参数，有返回值
  • 应用场景：
    • 函数内部的代码保持不变，针对不同的参数处理不同的数据，并且返回期望的处理结果

4.22.2. 函数的返回值进阶

• 函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理

• 返回值是函数完成工作后，最后给调用者的一个结果

• 在函数中使用return关键字可以返回结果

• 调用哈数一方，可以使用变量来接收函数的返回结果

• 返回多个结果：

  def mesure():
      temp = 39
      wetness = 50
  
      # 如果函数返回的类型是元组，小括号可以省略
      return temp,wetness
  
  # result为元组类型
  result = mesure()
  print(result)
  
  # 可以将一个元组使用赋值语句同时赋值给多个变量
  # 变量的数量需要和元组中的元素数量保持一致
  result = temp,wetness = measure()
  

• 交换两个数据

  a=6
  b=100
  
  a,b = b,a
  print(a,b)
  

4.22.3. 函数的参数进阶

• 不可变和可变的参数

  • 无论传递的参数是可变还是不可变，只要针对参数使用赋值语句，会在函数内部修改局部变量的引用，不会影响到外部变量的引用

  • 代码实例：(使用赋值语句)

    def demo(num,num_list):
        print("函数内部的代码")
    
        # 在函数内部，针对参数使用赋值语句
        num = 100
        num_list=[1,2,3]
        print(num)
        print(num_list)
        print("函数执行完成")
    
    gl_num = 99
    gl_list = [4,5,6]
    demo(gl_num,gl_list)
    print(gl_num,gl_list)
    

  • 代码实例：（使用方法）

    def demo(num_list):
        num_list.append(9)
        print(num_list)
    
    gl_list = [1,2,3]
    demo(gl_list)
    print(gl_list)
    

  • 代码实例：（列表变量调用+-，本质上是执行extend方法）

    def demo(num,num_list):
        print("函数开始")
        num += num
    
        # 对于列表变量，在使用+=时，本质上是在执行列表变量的extend方法，不会修改变量的			引用
        num_list += num_list
        print(num)
        print(num_list)
        print("函数结束")
    
        
    gl_num = 9
    gl_list = [1,2,3]
    demo(gl_num,gl_list)
    print(gl_num)
    print(gl_list)
    

• 缺省参数

  • 定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省参数

  • 调用函数时，如果没有传入缺省参数的值，则在函数内部使用定义函数时指定的参数默认值

  • 函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用

  • 代码实例：

    gl_num_list = [6,3,9]
    
    gl_num_list.sort()
    print(gl_num_list)
    
    gl_num_list.sort(reverse=True)
    print(gl_num_list)
    

  • 代码实例：（指定函数的缺省参数）

    def print_info(name,gender=True):
        gender_text = "男生"
        if not gender:
            gender_text = "女生"
    
        print("%s 是 %s" % (name,gender_text))
    

  • 注意：

    • 缺省参数的定义位置

      • 必须保证带有默认值的缺省参数在参数列表末尾

    • 调用带有多个缺省参数的函数

    • 在调用函数时，如果有多个缺省参数，需要指定参数名，这样解释器才知道参数的对应关系

    • 代码实例：

      def print_info(name,title="同学",gender=True):
          gender_text = "男生"
          if not gender:
              gender_text = "女生"
      
          print("[%s] %s 是 %s" % (title,name,gender_text))
      
      print_info("小明")
      print_info("老王",title="班长")
      print_info("小美",gender=False)
      

• 多值参数

  • 一个函数接收的参数不确定时，使用多值参数

  • 两种多值参数

    • 参数名前增加一个*可以接收元组
    • 参数名前增加一个**可以接收字典

  • 代码实例：（多值参数）

    def demo(num, *nums, **person):
        print(num)
        print(nums)
        print(person)
    
    demo("name",2,3,4,5,name="小明",age=18,gender=True)
    

  • 代码实例：（多值参数）

    def sum_numbers(*args):
        num = 0
        print(args)
        for n in args:
            num += n
        return num
    
    result = sum_numbers(1,2,3,8,89)
    print(result)
    

  • 代码实例：（元组和字典的拆包，元组加一个*，字典加两个*）

    def demo(*args, **kwargs):
        print(args)
        print(kwargs)
    
    gl_nums = (1,2,3)
    gl_dict = {"name":"小明","age":18}
    
    # 在元组前面加一个*，在字典前面加上两个*
    demo(*gl_nums,**gl_dict)
    

4.22.4. 递归函数

• 特点：一个函数内部调用自己

• 代码特点：

  1. 函数内部的代码是相同的，只是针对参数不同，处理的结果不同
  2. 当参数满足一个条件时，函数不再执行，称为函数的出口

• 代码实例：

  def sum_number(num):
      print(num)
      if num == 1:
          return
      sum_number(num-1)
  
  sum_number(3)
  

• 代码实例：（求和）

  def sum_numbers(num):
      # 1.出口
      if num == 1:
          return 1
      temp = sum_numbers(num-1)
  
      return num + temp
  
  result = sum_numbers(100)
  print(result)