Python基础

1 基础部分

1.1 语言常见分类

• 编译型和解释型
• 静态型和动态型
• 强类型和弱类型

1.2 编译与解释

（1）编译
特点：把程序源代码都编译成机器语言（二进制），保存为二进制文件（一次全部编译后运行）
优点：计算机可以直接运行，执行速度快
缺点：跨平台性较差
编译型语言：C、C++、Swift、Java、Go等

（2）解释
特点：在程序执行时才会一行一行地处理成机器语言（解释一行执行一行）
优点：跨平台性好
缺点：执行速度慢
解释型语言：Javascript、Python、PHP、Ruby等
运行需要解释器

（3）编译与解释的本质
计算机本身只能识别机器语言

1.3 计算机组成

（1）硬件系统
1）中央处理器（CPU）：计算数据和分配执行任务
2）存储器：
内存：临时存储数据，执行速度快，断电后数据丢失
外存：永久存储数据，断电后数据不会丢失，执行速度慢
3）输入设备：提供计算数据（键盘、鼠标、扫描仪、麦克风、摄像头等）
4）输出设备：显示最终计算结果（打印机、显示器等）

（2）软件系统
1）系统软件（Windows、Linux、macOS等）
2）应用软件（QQ、微信等）

1.4 程序执行原理

没有运行的程序保存在硬盘上，运行后被操作系统加载到内存中（变为进程）等待CPU的调度执行，CPU执行内存中加载的程序代码，完成计算输出结果

1.5 Python代码注释

作用：增加代码可读性
单行注释：# 一次只注释一行 , 快捷键：ctrl + /
块注释：””” 一次注释多行 “““ 或 ’’’ 一次注释多行 ‘‘‘

1.6 Python变量

变量：为快速定位目标数据，将数据在内存空间占据的空间分配的一个名称
定义：变量名 = 数据值 ，变量名要满足 标识符命名规则；
作用：临时存储数据

1.7 标识符命名

（1）标识符命名规则：
1）由数字、字母、下划线组成
2）不能使用数字开头
3）不能使用关键字
4）严格区分大小写
不能使用中文定义变量名

（2）命名习惯：
1）大驼峰: MyName
2）小驼峰: myName
3）下划线: my_name

1.8 Python关键字

1）关键字：具有特殊含义和功能的标识符
2）查看Python的所有关键字：
step1:导入工具包：import keyword
step2: 使用工具包中的工具：keyword.kwlist
3）可以直接使用关键字，但不能对关键字赋值

1.9 输出

（1）作用： 将程序运行结果输出打印到屏幕或终端
（2）格式化输出： 按照一定格式输出内容

• 1）常见的格式化符号：
  a. %06d, 表示输出的整数显示位数, 不足位以0补全, 超出当前位数则原样输出
  b. %.2f, 表示小数点后显示的小数位数, 此为保留2位小数
  c. 任何类型的数据都可转换为字符串类型，故%d,%f在print输出语句中，可替换为%s

• 2)格式化字符串：
  a. %s，print(“我的名字是：%s，明年%d岁” % (name,age+1)
  b. f’{表达式}'，print(f"我的名字是{name},明年{age+1}岁")
  c. 转义字符：
      换行：\n
      Tab键：\t
  d. 结束符：
      print(“输出的内容”, end=“\n”)
      在Python中， print()， 默认⾃ 带 end=“\n” 这个换⾏结束符

1.10 输入

（1）作用： 程序用来接收⽤户输⼊的数据
（2）语法： input(“提⽰信息”)
（3）特点:
1）input接收到用户信息，一般保存在变量中以便使用
2） input会把用户输入的任何类型的数据都当作字符串处理

1.11 运算符

（1）作用:
1）计算机可以完成多种类型的运算
2）不同类型的运算需要依赖不同的符号
3）运算符让计算机认识并处理对应的计算逻辑

（2）分类:

1）算数运算符：

• +：加
• -：减
• * :乘：可以用于字符串计算，如：print（“n” * 5），输出为：nnnnn
• / ：除
• %：取余
• // ：求商
• **：幂

2）比较运算符： 条件成立返回True，不成立返回False

• ==
• !=
• >
• >=
• <
• <=

3）逻辑运算符：
- and：两者都为真返回True，否则返回False
- or：一者为真即返回True，两者全假返回False
- not：取反操作，若为True，取反之后为False

4）赋值运算符：将运算符右侧的值， 赋值给左侧容器

• =
• +=：a + = b 等价于 a = a + b
• -=：a - = b 等价于 a = a - b
• *=：a *= b 等价于 a = a * b
• /=：a / = b 等价于 a = a / b
• %=：a % = b 等价于 a = a % b
• //=：a // = b 等价于 a = a // b
• **=：a ** = b 等价于 a = a ** b

（3）运算符优先级
1）按分类比较:
a. 算术运算符【由高至低】

• ()
• ** 幂等
• ＊ / // % 按书写顺序
• ＋ －

b. 逻辑运算符【由高至低】

• ()
• not
• and
• or

2）按类型比较【由高至低】

• **：幂
• *、/、%、//：乘、除、取余、求商
• +、-：加、减
• <=、>=、>、<：
• ==、!=：
• =、%=、*=、/=、//=、+=、-=、**=：赋值运算符
• not、and、or：逻辑运算符

1.12 数据类型

计算机工作的过程就是完成不同类型的计算，如：数学运算、文件存储、逻辑判断等，数据类型可对不同数据进行分类管理和标识，可通过 type() 函数返回当前变量或数据所属类型，type(数据) 或 type(变量名)。

数据类型分类：

• 整型，int，如：1
• 浮点型，float，如：4.6
• 布尔型，bool，如：True
• 字符串型，str，如：‘12345’
• 列表，list，如：[1,2,3,4,5]
• 元祖，tuple，如：(1,2,3,4,5)
• 集合，set，如：{1,2,3,4,5}
• 字典，dict，如：{‘name’:‘zhangsan’,‘age’:14}

2 数据类型

2.1 字典

2.1.1 定义

dict = {"键名1":"键值1","键名2":"键值2"......"键名n":"键值n"}

• 键必须是唯一的，创建时如果同一个键被赋值两次，后一个值会被记住
• 值可以取任何数据类型，但键必须是不可变类型

2.1.2 作用

在处理复杂业务，需要使用到不同类型的数据，通过字典在保存时对这些不同类型的数据加以区分；字典可以保存多个数据，且能给这些数据“起名字”以便区分。

2.1.3 常用操作及方法

（1）新增
字典名['键名'] = 新增键值
在字典中增加对应的键值对

（2）删除
1）del: del["具体键名"] 或 del 字典名
前者删除具体值，后者删除整个字典

2）clear： 字典.clear()
清空字典数据

（3）修改
字典名['键名'] = 键值
如果被修改的键名存在，直接用新值替换旧值；若不存在则新增

（4）查找
1）通过键名查找： 字典名["键名"]
通过键名查找对应的值，若键名不存在抛出异常
2）get: 字典名.get(key, default=None)
key： 字典中要查找的键。
default ：如果指定的键不存在时，返回该默认值

（5）其他方法
1）keys: 字典名.keys()
返回字典所有的键名，存放于列表中

2）values: 字典名.values()
返回字典对应的值，存放于列表中

3） items: 字典名.items()
将字典的每一个键值对都处理成元组， 存放于一个列表中

2.1.4 遍历字典

使用for循环遍历键名，for key in 字典.keys()

2.2 字符串

2.2.1 定义

（1）单引号字符串，如：‘单引号’
（2）双引号字符串，如：“双引号”
（3）三引号字符串，如：“”“三引号”“” 或 ```三引号```
（4）特殊符号处理，如： "I\'m zhangsan“,输出：I’m zhangsan
（5）去除特殊字符功能, 如： r"I\'m zhangsan“，输出：I\'m zhangsan

2.2.2 下标访问

字符串名[下标值]， 下标从0开始

2.2.3 字符串切片（列表和元祖也可进行切片操作）

字符串名[开始位置下标:结束位置下标:步⻓]
开始位置下标： 从0开始
结束位置下标：下标对应的字符不会被截取到
步长：设置截取间隔，默认为1，正负表示方向

```
 str = 'abcdefg'
 print(str[1:3:1])   # 输出：bc
 print(str[1:3)   # 输出：bc
 print(str[:3])    # 输出：abc
 print(str[1:])    # 输出：bcdefg
 print(str[:])    # 输出：abcdefg
 print(str[::2])    # 输出：aceg
 print(str[:-1])    # 输出：abcdef
 print(str[-3:-1])    # 输出：ef
 print(str[::-1])    # 输出：gfedcba
```

2.2.4 常用操作及方法

（1）查找
1）find()： 字符串.find(被查找字符,开始位置,结束位置)
省略开始位置和结束位置表示从头寻找至尾
若被查找字符存在，则返回第一次出现位置的下标；若不存在返回 -1

2）rfind(): 字符串.rfind(被查找字符,开始位置,结束位置)
同find()，不过从右侧开始查找

3）index(): 字符串.index(被查找字符,开始位置, 结束位置)
省略开始位置和结束位置表示从头寻找至尾
若被查找字符存在，则返回第一次出现位置的下标；若不存在抛出异常

4）rindex(): 字符串.index(被查找字符,开始位置, 结束位置
同index()，不过从右侧开始查找

5）count()： 字符串.count(被测试字符, 开始位置,结束位置)
省略开始位置和结束位置表示从头寻找至尾
统计被测字符出现的次数

6） len(): len(字符串)
返回字符串长度

（2）替换
replace()： 字符串.replace(原字符串, 替换字符串, 替换次数)
使用替换字符串， 按规则替换旧的字符串内容
字符串属于不可变数据类型，修改不会影响原来的空间

（3）判断
1） startswith(): 字符串.startswith(字符, 开始位置,结束位置)
判断目标字符串是否以 XXX 开

2） endswith(): 字符串.startswith(字符, 开始位置,结束位置)
判断目标字符串是否以 XXX 结尾

3）isspace(): 字符串.isspace()
判断字符串中是否包含空格，若包含空格则返回 True

4）isalnum(): 字符串.isalnum()
如果字符串中⾄少有⼀个字符并且所有字符都是字⺟或数字则返回 True

5） isalpha()： 字符串.isalpha()
如字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True

6） isdecimal()： 字符串.isdecimal()
如果字符串中只包含十进制字符则返回 True。这种方法只存在于unicode对象(unicode数字、全角数字)，若为byte数字将抛出异常’bytes’ object has no attribute ‘isdecimal’。
定义一个十进制字符串，只需要在字符串前添加 ‘u’ 前缀

7） isdigit()： 字符串.isdigit()
如果字符串中只包含数字则返回 True(Unicode数字、byte数字（单字节）、全角数字（双字节）、罗马数字)

8）isnumeric(): 字符串.isnumeric()
字符串是否只由数字组成，只针对unicode对象（Unicode数字，全角数字（双字节），罗马数字，汉字数字），若为byte数字将抛出异常

num = "1"  #unicode
num.isdigit()   # True
num.isdecimal() # True
num.isnumeric() # True

num = "1" # 全角
num.isdigit()   # True
num.isdecimal() # True
num.isnumeric() # True

num = b"1" # byte
num.isdigit()   # True
num.isdecimal() # AttributeError 'bytes' object has no attribute 'isdecimal'
num.isnumeric() # AttributeError 'bytes' object has no attribute 'isnumeric'

num = "IV" # 罗马数字
num.isdigit()   # True
num.isdecimal() # False
num.isnumeric() # True

num = "四" # 汉字
num.isdigit()   # False
num.isdecimal() # False
num.isnumeric() # True

9）istitle() ： 字符串.istitle()
如果字符串是标题化的(每个单词的⾸字⺟⼤写)，则返回 True

10） islower(): 字符串.islower()
如果字符串由小写字母组成，则返回true

11） isupper() ： 字符串.isupper()
如果字符串由大写字母组成，则返回true

(4) dir( )函数: 查看某类型中定义的⽅法
dir( str ) 显示字符串的所有⽅法

（5）大小写转换
1）capitalize() ： 字符串.capitalize()
把字符串的第⼀个字符⼤写

2）title()： 字符串.title()
把字符串的每个单词⾸字⺟⼤写

3） lower()： 字符串.lower()
将所有⼤写字符转换为⼩写

4） upper()： 字符串.upper()
将所有小写字符转换为大写

5）swapcase()： 字符串.swapcase()
字符串中大写转小写，小写转大写

（6）拆分和连接
1）partition(): 字符串.partition(字符串)
把字符串分成⼀个 3 元素的元组 (字符串前⾯部分, 字符串, 字符串后⾯部分)

2） split()： 字符串.split(分割符, num)
按制定字符分割字符串
num 为具体数值， 当分割符存在多次时， 可以设定使用几次
若不传入分隔符，默认以空格为分割

   str = "hello  Python or hello world or hello  hello"
   print(str.split("or"))  # 输出：['hello Python','hello world','hello hello']
   print(str.split("or",1))   # 输出：['hello Python','hello world or hello hello']
   print(str.split("",2))  # 输出：['hello' ,'Python','hello world or hello hello']
   print(str.split(""))  # 输出：['hello' ,'Python','or ','hello','world','or','hello','hello']

3）splitlines()： 字符串.splitlines()
按照⾏(‘\r’, ‘\n’, ‘\r\n’)分隔， 返回⼀个包含各⾏作为元素的列表

4）join()： 字符串.join(列表)
将列表按指定字符合并为字符串

    list = ['hello' ,'Python','or ','hello','world','or','hello','hello']
    print("-".join(list))  # 输出：hello-Python-or-hello-world-or-hello-hello

(7) 去除空⽩字符
1） lstrip(): 字符串.lstrip()
去除字符串左边（开始） 的空⽩字符

2）rstrip(): 字符串.rstrip()
去除字符串右边（末尾） 的空⽩字符

3）strip(): 字符串.strip()
去除字符串两边 的空⽩字符

（8）⽂本对齐
1） ljust(): 字符串.ljust(len)
返回⼀个原字符串左对⻬，并使⽤空格填充⾄⻓度len的新字符串

2） rjust(): 字符串.rjust(len)
返回⼀个原字符串右对⻬，并使⽤空格填充⾄⻓度len的新字符串

3） center(): 字符串.center(len)
返回⼀个原字符串居中对⻬，并使⽤空格填充⾄⻓度len的新字符串

2.3 元祖

2.3.1.定义

（1）tuple1 = (值1,值2,值3…值n)
（2）tuple2 = (值,) ，如果元祖中只有一个数值，也需要加逗号，否则会影响数据类型
（3）tuple3 = tuple()，实例化元祖

2.3.2 作用

用于存储多个数据，且这些数据不会被修改。

2.3.3 常用操作及方法

• 下标查找： 元祖[下标]
  返回下标对应的元素
• index： 元祖.index(具体元素)
  返回某个元素对应的下标，未找到抛出异常
• count： 元祖.count(具体元素)
  返回某个元素出现的次数
• len: len(元祖)
  • 返回元祖的长度

2.4 列表

2.4.1 定义

（1）list = [值1,值2,值3…值n]
（2）实例化：list = list()

2.4.2 作用

单个数据存放在变量中，多个变量组成的⼤量数据就可以存放在列表中，列表⽤于存放多个数据，列表是可变数据类型

2.4.3 常用操作及方法

（1）增加

• append： 列表.append(被添加数据)
  将被添加数据添加在列表的末尾

list = ["hello","Python","Java","HTML"]
list.append("CSS"）
print(list)  # 输出：['hello','Python','Java','HTML','CSS']

• extend： 列表.extend(被添加数据)
  若被添加的数据是可变类型，则将其中的值一一加入列表；若被添加的数据是不可变类型，则打散加入

list = ["hello","Python","Java","HTML"]
# 添加可变类型数据至列表
list.extend(["CSS","C++"])
print(list)  # 输出：['hello','Python','Java','HTML','CSS','C++']
# 添加不可变类型
list.extend("JS")
print(list)  # 输出：['hello','Python','Java','HTML','CSS','C++','J','S']

• insert： 列表.insert(指定位置, 数据)
  在指定位置插入新数据

list = ["hello","Python","Java","HTML"]
list.insert(1,"CSS")
print(list)  #输出：['hello',‘CSS’，'Python','Java','HTML']

（2）删除

• del: del 具体数值
  del 可以删除列表中的一个值， 或者整个列表，也可以删除其它数据类型

list = ["hello","Python","Java","HTML"]
# 删除单个数据
 del list[0]
 print(list)  # 输出：[‘CSS’,'Python','Java','HTML']
# 删除列表
del list  
print(list)  # list is not defined 

• pop: 列表.pop(下标)
  删除指定下标的数据（下标不写默认为0）， 并且返回被删除数据

list = ["hello","Python","Java","HTML"]
val = list.pop(1)
print(val)  输出：Python
print(list)  输出：['hello','Java','HTML']

• remove: 列表.remove(数据)
  在列表中删除第一个被匹配到的数据（不会返回被删除的值，如果被删除的数据有多个，仅删除第一次出现的数据)

list = ["hello","Python","Java","HTML","hello"]
list.remove("hello")
print(list)  输出：['Python','Java','HTML','hello']

• clear: 列表.clear()
  清空列表

list = ["hello","Python","Java","HTML","hello"]
list.clear()
print(list)  输出：None []

（3）修改

• 下标修改： 列表[下标] = 修改后的值
• reverse： 列表.reverse()
  倒置列表，返回None
• sort： 列表.sort(key=None, reverse=False)
  将列表按指定规则进行排序
  • key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse：排序规则，reverse = True 降序， reverse = False 升序（默认）

# 通过指定列表中的元素排序来输出列表
# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序
random.sort(key=takeSecond)
print (random)   # 输出：[(4, 1), (2, 2), (1, 3), (3, 4)]
       
# 降序输出
list = [2,3,5,7,1,0]
list.sort(reverse = True)
print(list)  输出：[7,5,3,2,1,0]

（4）查询

• 通过下标查询： 列表[下标]
• index： 列表.index(被查字符)
  查找目标数据， 返回指定下标
• count： 列表.count(数据)
  统计被测试值出现的次数
• len: len(列表)
  统计当前列表元素个数

（5）复制

• copy： 列表.copy()

（6）列表遍历

• 使用while

list = [1,3,5,6,7,22]
i = 0
while(i < len(list)):
    print(list[i])
    i += 1

• 使用for

list = [1, 3, 5, 6, 7, 22]
for item in list:
    print(item)

3 基本控制结构

3.1 判断结构

3.1.1 if语句

语法：

if 要判断的条件:
 	条件成⽴时执行的代码
     ……
else:
     条件不成⽴时执行的代码
     ……

3.1.2 elif多重判断

语法：

    if 条件1:
    	条件1满⾜执⾏的代码
    	……
	elif 条件2:
    	条件2满⾜时执⾏的代码
    	……
	elif 条件3:
    	条件3满⾜时执⾏的代码
    	……
	else:
    	以上条件都不满⾜时执⾏的代码
    ……

3.1.3 if嵌套

语法：

    if 条件1:
    	条件1满⾜时执⾏的代码
    	……
    	if 满足条件1基础上的条件2:
        	条件2满足时执行的代码
        	……
    	else:
	    	条件2不满足时执行的代码
	else:
	    条件1不满⾜时执⾏的代码
	……

3.2 循环结构

3.2.1 for循环

• 常用场景：
  （1）让指定的代码重复执行
  （2）遍历容器中的数据，逐个取出
• 语法：

  for 变量 in 容器:
      重复执⾏的代码
  

3.2.2 while循环

• 常用场景： 让执行的代码按照指定的次数重复执行
• 语法：

   定义计数器
   while 条件:
   	条件满⾜时执行的代码
   	计数器 + 1

循环结束后， 之前定义的计数器的数值是依旧存在的

• 举个🌰：打印九九乘法表

  i = 1
  while i <= 9:
  	j = 1
  	while j <= i:
  		print(f"{j} * {i} = {i * j} ",end = "")
  		j += 1
  	print()
  	i += 1
  

3.2.3 for…else…

• 常用场景： 定义循环结束之后要执行的操作，若循环终止，else下缩进代码不执行
• 语法：

  for 变量 in 容器:
      重复执⾏的代码
  else：
      循环正常结束执行的代码
  

4 函数

4.1 定义和调用

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

把具有独立功能的代码块组织为一个小模块，在需要的时候调用,函数名应符合标识符的命名规则。

若全局变量的数据类型是可变类型，在函数内部可以使用方法修改全局变量的内容，不会改变变量的引用，在函数内部使用赋值语句才会改变变量的引用。

list = [1,2,3,4]
print(f"初始时全局变量地址为：{id(list)}")
def demo1(str):
    list.extend(str)
    print(f"使用方法改变全局变量内容后的地址为：{id(list)}")
demo1("haha")

def demo2(list1):
    list = list1
    print(f"对全局变量进行赋值后的地址为：{id(list)}")
demo2([1,2])

# 最后输出为：
 # 初始时全局变量地址为：4318497216
 # 使用方法改变全局变量内容后的地址为：4318497216
 # 对全局变量进行赋值后的地址为：4318497280

4.2 作用

在开发程序时，通过函数提高代码的重用率，从而提高开发效率。

如果函数内部处理的数据不确定，可以将外界的数据以参数形式传递到函数内部。

如果希望一个函数执行完成后， 向外界汇报执行结果，就可以增加函数的返回值。

4.3 函数的文档注释

在定义函数下方通过三对连续的引号，在引号间编写对函数的说明文字；函数体相对独立，其定义上方，应和其他代码（包括注释） 保留两个空行。

在函数调用位置， 使用快捷键 CTRL + Q 可以查看函数的注释信息。

4.4 函数参数

（1）作用

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

（2）使用

def 函数名(形参1,形参2)
     封装的代码

在调用函数时,把参数传递到函数内部:

函数名(实参1,实参2)

（3）形参

定义函数时， 小括号中的参数， 是用来接收参数用的， 在函数内部作为变量使用。

（4）实参
调用函数时，小括号中的参数，用来把数据传递到函数内部。

（5）不可变参数和可变参数

• 无论传递的参数是可变类型还是不可变类型，只要针对参数使用赋值语句，就会在函数内部修改局部变量的引用，不会影响到外部变量的引用。
• 传递可变类型参数，在函数内部，使用方法修改了数据的内容，同样会影响到实参变量。
• 列表变量调用 += 本质上是在执行列表变量的 extend 方法，不会修改变量的引用。

（6）缺省参数

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

• 调用函数时， 如果没有传入缺省参数的值，则在函数内部使用定义函数时指定的参数默认值。将常见的值设置为参数的缺省值， 从而简化函数的调用

• 需注意：

  • 带有默认值的缺省参数必须在参数列表末尾。
  • 如果函数有多个缺省参数，在调用函数时，需要指定参数名，以便解释器清楚参数的对应关系。

• e.g.

def print_info(name,  gender = True, hobby = ""):
   gender_defaut = "女"
   if not gender:
       gender_defaut = "男"
   print(f"姓名：{name},性别：{gender}，爱好：{hobby}")
print_info("张三")  #输出：姓名：张三,性别：女，爱好：
print_info("张三",gender = False)  #输出：张三,性别：男，爱好：
print_info("张三",hobby = "打球")  #输出：姓名：张三,性别：女，爱好：打球

• 需要使用最常见的值作为默认值缺省值。
• 若一个参数的值不能确定，则不应设置默认值，具体的数值在调用函数时，由外界传递。

（7）多值参数
有时可能需要一个函数能够处理的参数个数是不确定的，这个时候，就可以使用多值参数：

• 参数名前增加 一个 * ：接收元组，一般命名为：*args

def sum(*args):
    sum = 0
    for i in args:
        sum += i
    return sum
print(sum(1,2,3))

• 参数名前增加 两个 * ：接收字典，一般命名为：**kwargs

元祖和字典的拆包：

• 在调用带有多值参数的函数时， 如果希望将一个 元组变量直接传递给 args，或将一个字典变量直接传递给 kwargs，就可以使用拆包简化参数的传递，拆包的方式是：
• 在 元组变量前， 增加 一个 *
• 在 字典变量前， 增加 两个 *

def demo(*args, **kwargs):
    print(args)
    print(kwargs)
nums = (1, 2, 3)
zhangsan = {"name": "张三", "age": 18}

# 会把 nums 和 zhangsan 作为元组传递给 args
demo(nums, zhangsan) # 输出：
# ((1, 2, 3), {'name': '张三', 'age': 18})
# {}

# 将⼀个元组变量/字典变量传递给函数对应的参数
demo(*nums, **zhangsan) # 输出：
# (1, 2, 3)
# {'name': '张三', 'age': 18}

4.5 函数返回值

返回值是函数完成工作后，给调用者的一个结果，用 return 关键字返回，可以使用变量接收结果，return关键字后的代码不会被执行。

在 Python 中， 可以将一个元组使用赋值语句同时赋值给多个变量（变量的数量需要和元组中的元素数量保持一致）。

4.6 模块中的函数

模块类似于一个工具包，想要使用模块中的函数，需要在使用import导入；在模块中定义的全局变量，函数都能提供给外界直接使用。

每一个以.py结尾的Python源代码文件都是一个模块

使用步骤：
step1: 导入模块 或 导入具体函数

import  模块名  或  
import  函数名 from  模块名

step2： 使用导入模块中定义的函数或变量

模块名.变量
模块名.函数

模块名也是一个标识符，若以数字开头，无法使用import导入

4.7 Pyc 文件

程序目录中的__virtualenv.cpython-39.pyc 文件，具体存放位置：工程名/venv/lib/python3.9/site-packages/_pycache__

（1）cpython-39中的 39 表示Python解释器的版本

（2）pyc文件是由 Python 解释器将模块源码转换的字节码文件，Python 这样保存字节码是作为一种启动速度的优化

（3）Python解释源程序的步骤：
step1： 处理源代码，编译生成一个二进制字节码
step2： 对字节码进行处理，生成CPU能够识别的机器码

（4）字节码：有了模块的字节码文件之后，下一次运行程序时，如果在上次保存字节码之后没有修改过源代码，Python 将会加载 .pyc 文件并跳过编译这个步骤，当 Python 重编译时，它会自动检查源文件和字节码文件的时间戳，如果修改了源代码，下次程序运行时， 字节码将自动重新创建。

4.8 匿名函数

（1）语法： lambda [arg1 ,arg2,.....argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2
print(sum( 10, 20 )) #输出：30

• 用lambda关键词能创建小型匿名函数，得名于省略了用def声明函数的标准步骤。
• Lambda函数能接收任何数量的参数但只能返回一个表达式的值。

（2）匿名函数的应用：

1）自定义函数：

def sum(a,b,opt):
 print(f"a = {a},b = {b},opt = {opt(a,b)}")
sum(1,2,lambda x,y:x + y) #输出：a = 1,b = 2,opt = 3

2）作为内置函数的参数：

stus = [
 {"name": "zhangsan", "age": 18},
 {"name": "lisi", "age": 19},
 {"name": "wangwu", "age": 17}
]
stus.sort(key = lambda x: x['age'],reverse=True)
print(stus)

4.9 哈希（hash）函数

哈希函数是Python的内置函数，接收一个不可变类型的数据作为参数，返回一个哈希值（整数）。

哈希是一种算法，其主要作用是提取数据的特征码，相同内容得到相同的结果，不同的内容得到不同的结果。

在 Python 中，设置字典的键值对时，会首先对 key 进行 hash 以决定如何在内存中保存字典的数据，以方便 后续 对字典的操作： 增、 删、 改、 查。

4.10 交换两个数字的方法

（1）使用其他变量

def exchange(a,b):
    temp = a
    a = b
    b = temp
    print(f"第一个数字是{a},第二个数字是{b}")
exchange(1,2) #输出: 第一个数字是2,第二个数字是1

（2）不使用变量

def exchange(a,b):
    a = a + b
    b = a - b
    a = a - b
    print(f"第一个数字是{a},第二个数字是{b}")
exchange(1,2) #输出:第一个数字是2,第二个数字是1

（3）利用元祖

def exchange(a,b):
    a,b = b,a
    print(f"第一个数字是{a},第二个数字是{b}")
exchange(1,2) #第一个数字是2,第二个数字是1

5 变量

5.1 变量的引用

变量和数据是分开存储在内存中的，变量中保存着数据在内存中的地址，这个地址，就叫做引用。如果变量已经被定义，当给一个变量赋值的时候，本质上是修改了数据的引用。变量保存数据地址的过程即为引用。使用 id() 函数可以查看变量中保存数据所在的内存地址。在 Python 中，函数的参数传递以及返回值都靠引用传递。

5.2 可变类型和不可变类型

（1）不可变类型： 内存中的数据不允许被修改。

• 数字类型：int , bool , float , complex , long
• 字符串：str
• 元组：tuple
  本质上不可变量类型在原值发生变化时，重新开辟空间生成了一个值的存储区域并引用了新的地址。

（2）可变类型： 内存中的数据可以被修改。

• 列表：list
• 字典：dict
  可变类型的数据变化是通过方法实现的，如果给一个可变类型的变量， 赋值了一个新的数据，其引用会修改。

5.3 局部变量和全局变量

（1）局部变量： 在函数内部定义的变量，只能在函数内部使用。

• 函数执行结束后，函数内部的局部变量，会被系统回收。
• 不同的函数，可以定义相同的名字的局部变量，彼此之间不会产生影响。
• 生命周期：局部变量在函数执行时才会被创建，执行结束后即被系统回收，局部变量在生命周期内，可以用来存储函数内部临时使用到的数据。

（2）全局变量： 在函数外部定义的变量， 所有函数内部都可以使用这个变量。

• 函数不能直接修改全局变量的引用，使用赋值语句修改全局变量的值。
• 如果在函数中需要修改全局变量， 需要使用 global 进行声明。
• 为了保证所有的函数都能够正确使用到全局变量， 应该将全局变量定义在其他函数的上方。
• 为了避免局部变量和全局变量出现混淆，在定义全局变量时，有些公司会有一些开发要求， 如：加 g_ 或者 gl_ 的前缀

在函数执行时，首先查找函数内部是否存在指定名称的局部变量，若存在，直接使用；如果没有，则查找函数外部是否存在指定名称的全局变量，若存在，直接使用。如果还没有，程序将抛出异常。

6 常用内置函数

（1） len（item）

• 计算容器中元素个数

（2）del
1）del 容器名[索引]

• 通过索引删除容器中元素

2）del( 容器名[索引] )

• del( ) 函数 通过索引删除容器中元素

3）del 容器名

• 将容器从内存中删除

4）del( 容器名 )

• del( )函数 将容器从内存中删除

注意:
字符串和元祖不支持 del 容器名[索引] 或 del( 容器名[索引] )

（3）max(item)

• 返回容器中元素最⼤值
• 如果是字典, 只针对 key 比较

（4）min(item)

• 返回容器中元素最小值
• 如果是字典, 只针对 key 比较

注意： 字符串比较本质是比较字符串对应的ASCII码

7 其他

7.1 生成随机数

step1: 导入随机数工具包

• import random

step2: 生成随机数

• random.randint(a, b) ， 返回 [a, b] 之间的整数， 包含 a 和 b

7.2 break 和 continue

7.1 break

• 在循环过程中，如果某一个条件满足之后， 不再希望循环继续执行，可以使用 break 退出循环

7.2 continue

• 在循环过程中，如果某一个条件满足之后，不希望执行循环代码，但是又不希望退出循环，可以使用 continue

• 结束本次循环(不执行continue后的循环体语句),执行下次循环

• * 条件处理部分的代码，在continue之前⼀定要修改计数器， 否则会陷⼊死循环