第七节 函数(重点)

掌握知识点

• 函数的定义
• 函数的调用方式
• 函数的4种分类
• 函数的返回值 return 多个
• 函数的嵌套使用
• 了解递归函数
• 函数传参的两种形式:位置参数,关键字参数
• 不定长参数 *args 和 **kwargs

1.1 概述

1. 就是组织好的,可以重复使用的, 用来实现单一或相关联的功能达代码段, 它能提高应用的模块化和代码的重复利用率. 减少代码的 冗余。
   • 例如 ：炒鸡蛋的一个方法、相当于特殊功能的 代码集。

   #A 来吃饭 ..
     print("将食材西红柿干净切碎...")
     print("西红柿和鸡蛋放到一起...")
     print("放入调料,大火猛炒,然后装盘出锅...")
   
   #B来吃饭 ...
      print("将食材西红柿干净切碎...")
      print("西红柿和鸡蛋放到一起...")
      print("放入调料,大火猛炒,然后装盘出锅...")
   
   #创建一个方法就可以,不用每次都这么搞,可以减少代码的冗余如何解决问题?
   
   
   

2. 函数的作用:
   • 当一个程序被 调用多次 的时候, 需要将重复的代码封装起来.并且简化设计流程
   • 方便重复使用,并且高级语言之中还有一些 内置函数。
     • 如:len(), sum() , max()等等。
   • 所以 合理的使用函数, 减少重复编写程序工作、 提高 编码效率。

   # 使用食材,鸡蛋做饭的方法
   	def eat():
   	    print("将食材西红柿干净切碎...")
   	    print("西红柿和鸡蛋放到一起...")
   	    print("放入调料,大火猛炒,然后装盘出锅...")
   	
   	
   	# 奥特曼来吃
   	eat()
   	print("-" * 40)  # 华丽的分割线
   	
   	# 小怪兽来吃饭
   	eat()
   

1.2 函数语法结构

1. 函数的定义其中的方法名,需要 遵循标识符的定义规则 .

   • 请说出标识符的命名规则? 可以参考变量命名规则

2. 如何 定义一个函数：

   • 函数 def 关键字 开头，后接 函数标识符名称 和 圆括号()。
   • 圆括号之间可以用于定义参数。
     • 分为 含参数。 和 , 无参数。
   • return [表达式] 结束函数。
     • 分为 有返回值。 和 无返回值。

3. 方法一定先定义,然后 再调用。

     def 函数名(参数1, 参数2...):
           '''
           函数方法说明,文档。
           '''
           # 具体处理问题的逻辑
           函数体: 写逻辑地方,如 if while print()等代码集.
           
           return 具体的返回值
   

• 格式解释：
  • def 表示这个是在定义函数.
  • 函数名 调用函数使用, 要符合 命名规则和命名规范.
  • 参数列表 形式参数, , 需要给函数传入什么值.也可以(有些参数可以设置默认值)
  • 函数体 用来完成某些逻辑功能的 (由 语句结构 组成)。
  • return 结束函数的,并且返回结果(也 可以是一个表达式)

1.3 函数四种分类

1.3.1 函数参数的传递

1. 函数使用的 细节：

   • 函数 必须先定义 才能使用。
   • 函数 必须调用 才会执行。
   • 函数的 功能越单一、越好。

2. 形式参数 和 实际参数

   • 定义方法时, 方法参数是形式参数、简称形参。
   • 调用方法时, 传递的参数, 是实际参数,、简称实参。

3. 现在问题来了, 我上面 “炒鸡蛋的方法完善一下”

   • 如果 、不想使用西红柿、想使用 黄瓜可不可以 ?
   • 这样的好处是什么 ?

   '''
   1. 带参数的方法
       鸡蛋的多种吃法 ,现在我不想使用西红柿了, 我想换成黄瓜?
           怎么做?
   
   '''
   #def eat(a): # 为什么不建议写a?
   def eat(food): #使用参数
       '''
       我是该方法说明: 
       :param food: 食物
       :return: none
       '''
       print(f"将食材{food}干净切碎...")
       print(f"{food}和鸡蛋放到一起...")
       print("放入调料,大火猛炒,然后装盘出锅...")
   
   eat(10) #可以么?
   eat(True)#可以么?
   print("*"*40) #华丽的分割线... ...
   eat("黄瓜") #可以么?
   

1.3.2 有参数,无返回值

1. 定义函数 、功能是来获取 两个整数的和。
   • 要求将 计算结果打印到控制台上。
2. 参数需要提前传递, 函数 相当于一台榨汁机, 前提需要往里面放水果.才能出水果汁
   • 这里的 水果就可以理解为参数.

   # 1.定义函数, 要求计算两个正整数的和,并打印在控制台上
   def getAdd(num_1, num_2): #形式参数
   # def getAdd(): # 这么写为什么,下面参数为什么会报错  ?
       '''
       定义函数 对两个正整数求和.
       :param num_1: 第一个整数
       :param num_2: 第二个整数
       :return: 无返回值  none
       '''
       # 也可以返回一个结果
       # num = num_1+num_2
       print(num_1 + num_2) #也可以返回一个表达式
   
   # 2.函数的调用,传递的实际参数
   getAdd(100, 200)
   getAdd(15, 20)
   print(getAdd(17,18)) #none 没有返回值就打印 none
   

1.3.3 有参数,有返回值

1. 为什么要有返回值?

   • 就是程序中的函数完成一件事情后,最后给调用者结果。
   • 将上面 求和案例、改成 有返回值 return 返回结果

   '''
   1. 就是需要将执行结果做一些事情,
           例如, 三个数,求平局值
   '''
   def getAdd(num_1, num_2, num_3):
       '''
        求三个数的和
       :param num_1: 第一个数
       :param num_2: 第二个数
       :param num_3: 第三个数
       :return:  num 三个数的和
       '''
       num = num_1 + num_2 + num_3
   
       return num
   
   # 赋值调用
   num = getAdd(10,20,30)
   print(num)
   
   #求平均值 
   # getAdd(10, 20, 30) #为什么没输出 ? 20 需要打印输出或者变量接收.
   avg = num / 3 
   print(int(avg))  # 20 
   
   

2. 赋值调用 和 输出调用。

   #第一种调用方式
   num = getAdd(10,20,30) # 赋值调用
   print(num)
   
   #第二种调用方式
   print(getAdd(10,20,30))  #输出调用
   

1.3.4 无参数,无返回值

1. 通过上面两个案例之后, 什么叫做无参数,无返回值?

   • 既 不能接收参数, 也 不能返回参数。
   • 做一个点菜系统。

   '''
   无参数,没有返回值
   
   '''
   def menu():
       num = int(input("请输入你选择的数字: "))
       if num ==1:
           print("火锅")
       elif num ==2:
           print("烤肉")
       elif num ==3:
           print("炒菜")
       else:
           print("您输入有误,请重新输入")
   
   
   # 调用点菜方法
   menu()
   

1.3.5 无参数,有返回值

1. 一般采集数据会用到这样的函数方式,
   • 体温计 显示温度.

   def get_info():
       # 通过控制台输入,模拟获取问题采集问题
       info = input("请输入温度: ")
   
       return info
   
   #1.调用方法,赋值输出
   value = get_info()
   print(value)#输出结果
   
   #2.打印输出
   #print(get_info())
   

1.4 变量作用域

1.4.1 作用域

1. 在Python中,程序的 变量并不是在哪个位置都可以访问 的,访问权限决定于这个变量在哪里赋值的。

   • “就近原则”,会优先在函数内寻找, 找不到在去外面找。

   a = "学校广播"  #全校班级都能听见
   def test():
       a = "班级广播" #只有自己班能听见,隔壁班听不见
       # a = "班级广播" #如果函数里没有,就去外面找.
       print(a)
   
   test() #谁听的最清楚? 班级广播
   

1.4.2 局部变量和全局变量区别

1. 定义位置不同

   • 局部变量: 定义在方法内部变量。
   • 全局变量: 定义在方法外的变量。

2. 定义格式不同

   • 局部变量: 变量名=变量值
   • 全局变量: global 变量名

3. 作用域不同

   • 局部变量: 只在当前 方法内部 (局部内)有效。
   • 全局变量: 只在 当前类文件中 都有效。 如.py文件中

   '''
   三个区别:
       位置
       范围
       格式
   '''
   
   def function_1():
       num = 100
       print(num)
   
   def function_2():
       num = 200
       print(num)
   
   #调用方法,中的num 相互不影响
   function_1()
   function_2()
   
   #输出num, 没有定义num
   print(num)# 为什么会报错?
   

1.4.3 global 关键字

1. 全局变量的范围.

   '''
   
   全局变量关键字
       global 使用
   '''
   num = "全局变量"
   def function_1():
       print(num)
   
   def function_2():
       print(num)
   
   #1.调用方法
   function_1()
   function_2()
   

2. 关键子 global 使用。

   • 在 函数作用域中 需要修改全局作用域或者外层嵌套作用域中的变量时, 则需要使用该关键字.
   • global num = 200 注意,不支持这样声明,必须拆分写

   '''
   全局变量关键字
       global 使用
   '''
   num = "全局变量"
   def fuction_1():
       print(num)
   
   def function_2():
       # 2. 在function中修改外局部变量
       # num = 300  #只是修改了局部变量
       global num
       num = "修改成功了么"
       print(num)
   
   
   # 1.调用方法
   #function_2() 如何先执行 2会有什么结果
   fuction_1()
   function_2()
   print("*"*30)
   #在调用fuction时, 为什么会改变了?
   fuction_1()
   
   

1.5 return 返回多个值

1. 许多编程语言中，函数通常只能返回单个值。

   '''
   return 返回多个值.
           案例,通过模拟计算器。
   '''
   
   def calculator(a, b):
       '''
           method 计算器方法
       :param a: 参数 a
       :param b: 参数 b
       :return:  加 减 乘 除
       '''
       addition = a + b
       subtraction = a - b
       multiplication = a * b
       division = a // b  # 向下取整
       #一个相当牛b的写法, 只有python中有.
       return addition, subtraction, multiplication, division
   
   
   #2. 调用方法
   resault=calculator(10,5)
   print(resault) # 相当于返回一个元组. (15, 5, 50, 2)
   
   #2.1 返回单个结果
   print(f"加法: {resault[0]}, 减法: {resault[1]},乘法: {resault[2]},除法: {resault[3]}")
   

1.6 函数的嵌套使用

1. 相当于在 一个函数中调用另一个函数。

   '''
   函数又叫做方法,
       函数的嵌套使用就相当于在方法中调用另一个方法.
   '''
   
   
   # 定义方法
   def function_1():
       print("function_1 start...")
       print("只因你太美... ")
       print("唱 ,跳 ,rap,篮球 ")
       print("function_1 end...")
   
   def function_2():
       print("function_2 start...")
       #   TODO 正常逻辑代码
       function_1() #在方法2中调用方法 1
       print("function_2 end...")
   
   
   #2.调用方法
   #function_1()
   function_2() # 在方法中调用方法1 
   

2. 递归函数

1. 什么是递归函数? 在之前学习过在一个函数里可以调用另一个函数、叫函数的嵌套.
   • 思考,如果在一个函数内部 调用了函数的本身, 那么这个函数就是 递归函数。

2.1. 使用递归计算阶乘

1. 通过案例: 计算阶乘 n!=1*2*3*4*....n 的例子来 演示递归函数 的使用。

   '''
   什么是递归函数?
       就是在方法中自己调用自己.
   案例: 计算阶乘的一个函数
       n!=1*2*3*4...n
   '''
   def func(num):
       '''
       计算阶乘
       :param num: 计算阶乘
       :return:
       '''
       #相当于出口条件,结束递归.
       if num == 1:
           return 1
       else:
           return num * func(num - 1) 
   
   # 调用方法
   number = func(3)  # 3! = 1*2*3
   print(number)
   

2. 注意：在使用递归时，必须设置一个出口条件，也称为递归基例（base case），

   • 它指明了递 归函数应该在何时停止调用自身 并返回结果。如果没有出口条件，递归函数将无限循环调用，导致堆栈溢出错误。
   • 出口条件通常是在 问题可以直接求解时的情况下触发，因此它应该是一个简单的情况，不再需要递归调用就能直接返回结果。
   • 递归函数在每次调用时都应该朝着 解决问题的出口条件逼近。

    	        func(3)
               /   \
           3 *       func(2)
                   /   \
               2 *       func(1)
                       /   \
                   1       return 1
   

3. 函数的传参

3.1 实参对应形参位置

1. 按照函数形式参数 的位置, 将实际参数的值传递给行参。
   • 即位置 对应。
   • 数量 对应。

   '''
   1. 函数传参问题:
           1.1 按照函数形式参数的位置, 将实际参数的值传递给形式参数。
   '''
   
   # 2. 创建方法
   def show(name, age, address):
       '''
           显示个人信息
       :param name: 名字
       :param age: 年龄
       :param address: 地址
       :return: none
       '''
       print(f"名字: {name}, 年龄:{age},地址: {address}")
   
   
   # 3.调用方法  形式参数位置,与传递实际参数位置保持一致
   show("刘亦菲", 34, "北京")
   
   # 3.1 假如位置,不一致,虽然不报错,但是需要!!避免
   show(34, "刘亦菲", "北京")
   
   # 3.2 少参数
   # show("刘亦菲",34) # show() missing 1 required positional argument: 'address'
   
   

3.2 关键字传递参数

1. 指定实际参数,给到哪个形式参数。
   • 关键字同 函数的形式参数的名字要保持一致。

   # 1. 创建方法
   def show(name, age, address):
       '''
           显示个人信息
       :param name: 名字
       :param age: 年龄
       :param address: 地址
       :return: none
       '''
       print(f"名字: {name}, 年龄:{age},地址: {address}")
   
   	# 1, 使用形式参数的关键字同名进行传递参数。
   	show(age=34,name="刘亦菲",address="北京南城")
   

2. 也可以混合使用,
   • 但是 关键字参数一定要放到位置参数后面。

   #3.混合使用
   #3.1 位置放到后面
   show("刘亦菲",address="北京2",age=18)
   #3.2 这样就会报错 
   #show(age=18,"刘亦菲",address="北京")
   

3.3 默认参数

1. 定义函数时、可以给函数的参数设置默认值、 这个参数就被称为默认参数。
   • 有些字段有自己默认含义,如果你传递我就按照你传递参数意思, 如果不传递我就按照默认值 。

   	'''
   	1.默认参数
   	'''
   	
   	# 在祖国境内都属于中国人
   	def showInfo(name, country="中国"):
   	    print(f"我的名字是: {name},现在,所在地{country}")
   	
   	
   	# 1.1使用默认参数
   	showInfo("后裔")
   	# 1.2 传递参数 改变 country
   	showInfo("夸父", "宇宙")
   	
   

2. 在实际开发中需要注意：
   • 默认参数 一定要在 方法形参列表中,最后一位、不然会报错。

   	#2. 如果不在最后一位会报错,默认参数
   	def showInfo(name, country="中国",sex):
   	    print(f"我的名字是: {name},现在,所在地{country}")
   

3.4 不定长参数

1. 通常定义一个函数时, 若希望函数能够 处理的参数个数比当初定义的参数个数多, 此时可以在函数中使用不定长参数。

   • 所谓：不定长参数 ,指的就是 参数的个数是可以变化的。

2. 定义语法格式

   • 表达式中有三个参数: 其中 form_args 为形参(如,a,b之前所用参数)
   • *args 和 **kwrgs 为不定长参数。
   • 当调用函数时候、函数会优先匹配行参个数(form_args) ,如果超过匹配行参个数就会有如下两种情况:
     • 1. 如果传入的 参数没有名称 那么 *args 会以 元组 的形式存放这些多余的参数。
     • 2. 如果传入的 参数指定名称 例如: m=1,那么 **kwargs 会以字典的形式 存放这些被命名的参数, {m:1}

   #语法格式如下 
   
   def func([formal_args,] *args,**kwargs ):
       '''方法说明_文档'''
       函数体
       return  表达式
   

3. 不定长参数的 简单使用

   • *参数名, 一般写 *agrs ,表示不定长元组, 接受所有 位置参数
   • **参数名,一般写 **kwargs ,表示不定长字典,接受所以 关键字参数

   	
   #创建一个方法,带有不定长参数
   # def func(a,b): #方法只定义两个普通参数。
   def func(a,b,*args):
       print(a)
       print(b)
       print(args)
       #print(type(args))
   
   # 调用方法1,传递参数
   func(10,20) #10 20 ()
   
   #调用方法2,传递多少都没有关系
   func(11,12,13,14,15,16)
   
   print("-"*50) #华丽的分割线
   
   #2. 不定长参数  **kwargs 需要传递的是关键字参数 
   def func2(a,b,*args,**kwargs):
       print(a)
       print(b)
       print(args)
       print(kwargs)
       # print(type(kwargs))
   
   #2.调用函数
   func2(4,2,3,4,name="你好")	
   		
   

   • 输出结果

   10
   20
   ()
   11
   12
   (13, 14, 15, 16)
   --------------------------------------------------
   4
   2
   (3, 4)
   {'name': '你好'}
   

3.4.1 不定长参数运行方式

1. 不定长参数,运用的方式

   • 定义方法时, 不知道后期是否会发生多参数个数传递情况。使用不定长参数

   '''
   主要定义格式使用:
       def func_1(a,b):
       def func_1(a,b,*args): 或者  def func_1(*args):
   '''
   
   # 1.不定长参数
   def func_1(a, b):
       print(a)
       print(b)
   
   # 1.1 调用函数,传递多余位置参数
   # func_1(10,20,30)#当多余一个元素时肯定会报错.
   
   print("-" * 40)  # 华丽分割线
   
   
   # 1.2两种形式解决问题:
   # 1.2.1 使用 不定长参数 *args语法
   def func_2(a, b, *args):
       print(a)
       print(b)
       print(args)
   
   
   # 调用函数
   func_2(10, 20, 30, 40, 50)
   
   print("-" * 40)
   
   
   # 1.2.2 直接定义 不定长参数
   def func_3(*args):
       print(args)
   
   # 使用*args不定长函数的使用方式
   func_3(10, 20, 30, 40)
   
   

2. 函数的参数, 说明情况。

   • 方法定义时, 位置参数在前, 默认参数在后.

   # 演示带所有函数的参数
   #a 普通参数  b 是默认参数, *args不定长参数(元组) ,**kwargs 不定长参数(字典)
   def func(a,  b=10,  *args,   **kwagrs):
       pass #空语句
   
   
   # 8是位置参数, b=8 是关键字参数
   #注意: 是位置在前,关键字在后.func(b=89,19)这样不可以
   func(8,b=8)
   
   

3.4.2 实际运用(求和案例)

1. 使用函数求和的另一种方式,如果不确定传递参数个数, 就使用不定长参数。

   • 实际案例中灵活使用 不定长参数。
   • 扩展在java中叫做可变参数。 func(int...num)

   	#版本1: 功能相似 参数列表不同
   	# 功能相似,但是参数列表不同,在java中叫做可变参数(int ...a)
   	def func_1(a, b):
      		 return a + b
   	def func_2(a, b, c):
       	return a + b + c
   
   print("-"*40) #华丽的分割线
   
   #版本2:使用不定长参数解决多个数求和问题
   # 在实际开发中程序的设计,并不能一开始就确定参数个数是多少.
   #定义方法
   def add(*args):
       '''
       使用不定长参数求和
       :param args: 多个参数
       :return: 求和
       '''
       sum = 0 #累计求和
       for i in args: # *args是一个参数元组
           sum+=i
       # print(sum)
       #将参数的方法返回
       return sum
   
   
   #调用方法
   print(add(10,20,30))
   print(add(10,20,30,40,50))
   print(add())
   

4. 拆包

4.1 拆包

1. 在Python中，拆包（unpacking）是一种 将可迭代对象中的元素解析为单独变量的过程。 这样可以方便地获取可迭代对象中的值，并将其赋给变量。
2. 拆包在处理元组、列表、字典等数据结构时非常有用。
   • 细节： 容器中元素的个数和需要的变量个数必须保持一致。
   • 例如 ： 容器有4个值, 则拆包需要3个变量。

   '''
   拆包使用 : 容器类型
       1. 元组
       2. 列表
       3. 字典
   '''
   
   #将容器类型(list,tuple,dict)拆分成多个变量
   tuple_1 =(10,20,30)
   #1.1 进行拆分
   # a,b,c,d = tuple_1 #数量要一致
   a,b,c = tuple_1
   print(a)
   print(b)
   print(c)
   
   
   print("-"*40)
   
   #2.拆分列表
   list_1 = ["王一博","吴琼","杨洋"]
   l1,l2,l3=list_1 #2.1 注意参数和列表个数一定要对。
   print(l1,l2,l3)
   
   #3. 拆分字典,拆包之后获取的: 键
   dict_1 = {"name":'王一博',"age":24}
   #注意拆包之后获取的是键 
   #key value = dict_1 # 打印的也是键值 
   key1,key2 =dict_1
   print(key1,key2)#可以通过key获取对应value的值
   
   print(f"{key1}:{dict_1[key1]}   和  {key2}:{dict_1[key2]}")
   

4.2 拆包的使用场景

1. 提起拆包的使用场景肯定不会陌生。

   #遍历,字典的两种方式 
   dict_1 = {"name":'王一博',"age":24}
   for item in  dict_1.items():
       print(item[0],item[1])
   
   #第二种拆包的体现:
   for key,value in dict_1.item(): #其中的 key ,value就是拆包的体现
   	print(key,value)
      
   

4.3 扩展点: 组包

1. 在Python中，组包（packing）是一种将多个变量打包到一个容器对象中的过程、正好与拆包相反。

   • 可以理解为,将多个元素存储到容器中。

   	'''
   	将多个元素,存放到容器中
   	'''
   	#1.组包 元组
   	tuple_1 =10,20,30 #如果不写()默认为元组
   	print(type(tuple_1))# 类型
   	print(tuple_1)
   
   	#2. 组包 列表
   	list_1 =[10,20,30]
   	print(type(list_1))
   	print(list_1)
   

5. 引用 (理解)

5.1 什么是引用 ?

1. 在Python中，引用（reference）是指一个变量指向（引用）一个对象的内存地址。 当我们将一个对象赋值给一个变量时，实际上是将该对象的引用赋给了该变量。

   • id() 可以查看 引用地址。

    a = 10 
   

   • 在这个例子中，变量 a 是一个引用，它指向内存中的整数对象 10。我们 可以通过 a 来访问和操作这个整数对象。

2. 引用的概念在Python中非常重要，因为它涉及到变量的使用、内存管理和对象之间的关系。

   • Python中的引用是动态的，这意味着我们可以改变一个引用所指向的对象。

   a = 20 
   

   • 我们可以将 变量 a 的值改变为另一个整数对象：

3. python中一切的 传递都是引用（地址），无论是赋值还是函数调用。

   '''
   1.引用:
       指一个变量指向一个对象地址值。
   '''
   # 把10的内存地址值赋值(引用id()可以查看)给变量a
   a = 10
   # 把20的内存地址值(引用)赋值给 变量b
   b = 20
   # 把a的引用赋值给变量b
   b = a
   
   # 得出的结论 a的地址值,应该和 b一样。
   print(a, id(a))
   print(b, id(b))
   
   print("-" * 40)  # 分割线
   
   # 2. 将20的引用赋值给 a变量.
   a = 20
   print(a, id(a))  # 20 140719029278976
   
   

4. a = 20 ，这里并非真正修改了对象的值，而是改变了变量 a 的引用，使其指向新的整数对象 20 。

   • 引用的机制 在Python中非常重要，我们可以更好地理解Python中变量的赋值、传递 和 作用域。
     
     

5.2 可变类型和不可变类型(理解)

1. 类型可变和不可变类型、是有划分依据的：

   • 就是不改变(引用地址的情况下、就是内存地址值) 、能否修改变量内容。
   • 可以[不改变]、 就是可变类型。不可以[不改变]、 就是不可变类型。
   • 查看内存地址值函数 id()

2. 具体分类：

   • 可变类型： list 列表、dict字典。
   • 不可变类型: int、float、bool、str、tuple、set。

3. 不可变类型

   • 修改内容之后, 地址值发生了改变。

   '''
   1. 演示不可变类型
       修改变量内容,地址值也会发生改变.
   '''
   # id()查询地址值,内存。
   # string 类型不可变类型
   str_1 = "123"
   print(str_1, id(str_1))
   
   str_1 = "124"  # 修改值
   print(str_1, id(str_1))  # 内存中地址值也发生了改变。
   
   print("-" * 40)  # 华丽的分割线
   
   #int类型不可变类型
   int_1 = 123
   print(int_1,id(int_1))
   
   int_1 =124
   print(int_1,id(int_1))
   

   • 输出结果

   123 1834380549680
   124 1834380549552
   ----------------------------------------
   123 140732445681120
   124 140732445681152
   
   

4. 可变类型

   • 修改内容之后、地址值没有发生改变。

   '''
   2. 不可变类型
       修改内容之后,地址值没有发生改变。
   '''
   # 容器类型
   list_1 = [11, 12]
   print(list_1, id(list_1))#[11, 12] 3037210209216
   
   # 添加数据
   list_1.append(13)
   print(list_1,id(list_1))#[11, 12, 13] 3037210209216
   
   #注意:  相当于从新创建了一个新的列表,所以发生了改变
   list_1 =[22,44]
   print(list_1,id(list_1))#[22, 44] 3037210448000
   

5. 在Python中，列表（List）是动态数组，可以自动扩容 以适应存储更多的元素。当列表的元素数量达到当前容量时，系统会自动增加内部的存储空间，以容纳更多的元素。

   • 可以把列表比做套房、套房中有很多空间。
     

6. 函数介绍Api

6.1 时间函数time()

1. 时间戳、表示的是从1970年1月1日00:00:00 开始按秒计算的偏移量。

   • 返回时间戳的函数 time()
   • 需要导入time 模块

   '''
   时间函数
       是一个时间戳从1970年1月1日开始 00:00:00 开始按秒计算
   '''
   #导入time模块
   import  time
   
   begin = time.time()
   print(begin)#1689254319.0681674
   
   

2. 上述的格式不利于阅读、需要格式化的时间字符串。

   • 通过time模块的strftime函数可以返回一个格式化的日期与时间。

   #format 参数表示格式化字符串 t 是可选参数,它是一个时间元组
   	time.strftime(format[ 、t])
   

   • 格式化的时间字符串

   '''
   # 通过time模块的strftime 函数可以返回一个格式化的日期与时间
   import time
   
   a = time.localtime()  # 返回一个元组
   print(a)
   print("-" * 40)  # 华丽的分割线
   # 使用"%Y-%m-%d %H:%M:%S"形式 格式化 a
   print(time.strftime("%Y-%m-%d %H:%M:%S", a))
   

3. time.sleep(秒),休眠

   import time
   i =1
   while i<100:
       print(i)
       time.sleep(1) #时间休眠 1秒 
       i+=1
   

6.2 随机函数 random()

1. random模块用于生成随机数、它提供了很多函数。

   • random.rangdom() 返回0~1之间的随机浮点数N、 范围0<=N<1.0

   import  random
   #生成第一个随机数
   a = random.random()
   #生成第二个随机数 
   a_1 =random.random()
   #随机生成100个
   for i in range(100):
       num = random.random()#随机数
       print(num)
   

   • random.randint(a,b) 返回一个随机的整数N 、 其中a,b是整数。 N的取值范围为 a<=N<=b

   import  random
   a=random.randint(1,3)#随机生成 1~3的整数
   print(a)
   

   • random.choice(参数) 、其中参数可以是列表、字符串。

   #随机返回一个元素
   a_1 =random.choice("好好学习,天天向上")
   a_2 =random.choice(["好好","学习","天天","向上"])
   print(a_1)
   print(a_2)
   

   • random.shuffle() 洗牌,打乱列表

   #无返回值方法, 排序完生成
   list_1 = ["hello", "my", "son"]
   #静态方法直接使用,相当于java中的Collections
   random.shuffle(list_1)#无返回值方法
   print(list_1)#['son', 'my', 'hello']