操作系统首先先让CPU把程序复制到内存中
CPU执行内存中的程序代码
程序就是用来处理数据的，而变量就是用来存储数据的
操作系统首先会让CPU把Python解释器的程序复制到内存中
Python解释器根据语法规则，从上向下让CPU翻译Python程序中的代码
CPU负责执行翻译完成的代码
编译型语言：程序执行之前需要一个专门的编译过程，把程序翻译成为机器语言的文件。运行时候不需要重新编译，直接用编译结果就好了。程序执行效率高，依赖编译器，跨平台性差
解释型语言：编写的程序不需要预先编译，以文本的方式存储代码，会将代码一句一句直接运行。运行程序的时候，必须先解释在运行
速度：编译型语言比解释型语言执行速度快
跨平台性：解释型语言比编译型语言快
Python源程序就是一个特殊格式的文本文件，可以使用任意文本编辑软件做Python开发
Python程序的文件扩展名通常都是 .py
print("Hello Python")
print("Hello World")
#语法错误 后面不能有其他语句，可以有注释
print("Hello Python")print("Hello World")
#语法错误 多余的缩进 （每行代码前面都不要加空格）
print("Hello Python")
虚拟机中执行Python文件：
使用Python2.X解释器：python 文件名.py
使用Python3.X解释器：python3 文件名.py
交互式运行Python程序(命令行敲python/python3)：
直接在终端中运行解释器，而不输入要执行的文件名。在Python的shell中直接输入Python的代码，会立即看到程序执行结果
优点：审核学习/验证Python语法或者拒不代码
缺点：代码不能保存，不适合运行太大的程序
直接退出:exit(),热键退出：ctrl+d
建议使用ipython(ipython/ipython3)
直接退出：exit，热键退出：ctrl+d
Python2.X不支持中文
Python3.X支持中文
Python3.0没有考虑向下兼容，早期版本无法在Python3.0上运行
# 单行注释 """ 多行注释 多行注释 """算数运算符
+ 相加，- 相减，* 相乘，/ 相除，// 取整除，% 取余除， ** 幂运算
算术运算符的优先级
先乘除后加减，同级运算符从左至右计算，可以使用()提高计算的优先级
10 + 20 10 - 20 10 * 20 10 / 20 9 // 2 # 4 9 % 2 # 1 2 ** 3 # 8 2 + 3 * 5 # 17 (2 + 3) * 5 # 25 # 打印10个-。 ---------- "-" * 10变量
定义变量
变量名 = 值
# 定义一个变量记录qq号码 qq_number = "123456" # 使用交互式可以直接输入变量名就可输出变量值 qq_number # '123456' # 使用解析器的方式，输出变量内容，是要使用print函数 print(qq_number) # '123456' # 定义一个变量记录qq密码 qq_password = "12333" print(qq_password) # '12333' # 案例超市买苹果,只要买苹果就要返5元 # 1.定义苹果的单价 price = 8.5 # 2.挑选苹果 weight = 7.7 # 3.计算付款金额 money = price * weight # 4.只要买苹果就返5元 money = money - 5 print(money) # 63.75
变量的类型
在Python中，定义变量不需要制定变量的类型的
在运行的时候，Python解释器，会根据赋值语句等号右侧的数据自动推导出变量中保存数据的准确类型
数据类型可以分为 数字型 和 非数字型
数字型：整型(int),浮点型(float),布尔型(bool),复数型(complex)
布尔型：真True。 非0数，非0即真
假False。0
复数型：主要用于科学计算。例如：平面场问题，波动问题，电感电容等问题
非数字类型：字符串,列表,元祖,字典
在python2.x 中整数还分为int 和 long
typer(变量名) 判断变量的数据类型。 在ipython中经常使用
# 案例记录 小明 的属性 # str 表示字符串类型 name = "小明" # int 表示整数类型 age = 18 # bool 表示布尔类型 gender = True # 是 True表示是男生 # float 表示浮点型 height = 1.75 # float 表示浮点型 weight = 75.0
不同的数据类型之间的计算
1.数字类型之间可以直接计算
2.如果变量是bool型，在计算时候
True对应数字1
False对应数字0
i = 10 f = 10.5 b = True i + f #20.5 i + b #11 f - b #9.5 i * f #105 #字符串变量使用 + 拼接 first_name = "张" last_name = "三" first_name + last_name #张三 #字符串变量使用 * 重复拼接相同的字符串 "-" * 5 #----- (first_name + last_name) * 5 #张三张三张三张三张三 #数字类型变量 和 字符串之间 不能进行其他运算 first_name + 10 #报错 first_name + "10" #张10
变量的输入
用代码获取用户通过键盘的输入信息
input函数，用户输入的任何内容都是字符串
input()
#然后输入你想输入的信息
input("可以写入提示信息在里面")
#可以使用变量接收input输入的数据
password = input("请输入密码:")
print(password)
type(password) #str
类型转换函数
int("123")
float("10.23")
"""
变量输入演练
收银员输入苹果的价格，单位：元/斤
收银员输入苹果的重量，单位：斤
"""
#输入苹果的单价
price_str = input("苹果的单价：")
#输入苹果的重量
weight_str = input("苹果的重量：")
#计算支付的金额
money = float(price_str) * float(weight_str)
print(money)
变量的格式化输出
如果希望输出文字信息的同时，一起输出数据，就需要使用到格式化操作符
%被称为格式化操作符，专门用于处理字符串中的格式
包含%的字符串，被称为格式化字符串
%和不同的字符连用，不同类型的数据需要使用不同的格式化字符
%s 字符串
%d 有符号十进制数，%06d表示输出的整数显示位数，不足的地方使用0补全
%f 浮点数，%.2f表示小数点后只显示两位
%% 输出%
#定义一个字符串变量name，输出 我的名字叫 小明，请多多关照
name = "小明"
print("我的名字叫 %s，请多多关照" % name)
#定义一个整数变量 student_no 输出 我的学号是 000001
student_no = 000001
print("我的学号是 %06d" % student_no)
#定义小数price、weight、money输出 苹果的单价9.00元/斤，购买了5.00斤，需要支付45.00元
price = 9.00
weight = 5.00
money = price * weight
print("苹果的单价%.2f元/斤，购买了%.2f斤，需要支付%.2f元" % (price, weight, money)
#定义一个小数scale，输出 数据的比例是10.00%
scale = 10.00
print("数据的比例是%.2f%%" %scale)
print("数据的比例是%.2f%%" %scale * 2) #数据的比例是10.00%数据的比例是10.00% #字符串输出两次
print("数据的比例是%.2f%%" (%scale * 2)) #数据的比例是100.00%
标识符
标识符就是程序员定义的 变量名、函数名
名字需要有见名知意
标识符可以由 字母、下划线和数字组成
不能以数字开头
不能与关键字重名
关键字
关键字就是Python内部已经使用的标识符
关键字具有特殊的功能和含义
开发者不允许定义和关键字相同的名字的标识符
# 查看Python中的关键字 import keyword print(keyword.kwlist)
变量的命名规范
注意：Python中标识符是区分大小写的
1.在定义变量时，为了保证代码格式 "="的左右应该各保留一个空格
2.在Python中，如果变量名需要由二个或多个单词组成的，可以按照以下方式命名
a.每个单词都使用小写字母
b.单词与单词之间使用 _下划线链接
c.例如：first_name、last_name
3.可以使用驼峰命名法
小驼峰：firstName
大驼峰：FirstName
格式一：
if 要判断的条件:
条件成立,要做的事情
...
格式二：
if 要判断的条件:
条件成立,要做的事情
...
else:
条件不成立,要做的事情
...
格式三：
if 条件1:
条件1满足执行的代码
...
elif 条件2:
条件1满足执行的代码
...
elif 条件3:
条件1满足执行的代码
...
else:
以上条件都不满足执行的代码
...
也可以嵌套if判断
if 条件1:
条件1满足执行的代码
...
if 条件2:
条件2满足执行的代码
...
else:
条件都不满足执行的代码
...
注意：代码的缩进为一个tab键,或者4个空格(建议使用空格)
在Python开发中，Tab和空格不要混用
#案例 判断年龄
# 定义一个年龄变量
age = 18
#判断是否满了18岁
if age>=18:
# if后面的缩进是一个完整的代码快
# 以下两行代码if的判断为True才会执行
print("你已经成年了")
print("成年可以去网吧")
print("此时没有缩进不属于代码块内，不受if语句的影响")
############################
#if else 可以看做为一个完整的代码块#
if age>=18:
print("你已经成年了")
print("成年可以去网吧")
else:
# 如果没有满18岁，提示回家写作业
print("你还没有成年，请回家写作业吧")
print("此时没有缩进不属于代码块内，不受if else语句的影响")
#案例：女友的节日
#如果是情人节应该买玫瑰/看电影
#如果是平安夜应该买苹果/吃大餐
#如果是生日应该买蛋糕
#其他日子每天都是节日
holiday_name = "生日"
if holiday_name == "情人节":
print("买玫瑰")
print("看电影")
elif holiday_name == "平安夜":
print("买苹果")
print("吃大餐")
elif holiday_name == "":
print("买蛋糕")
else:
print("每天都是节日啊...")
#案例 火车站安检
#定义布尔型变量has_ticket表示有车票
#定义整型变量knife_length表示刀长度。单位：厘米
#首先检查是否有车票，再检查刀的长度是否超过20厘米
#定义是否有车票
has_ticket = True
#定义刀的长度
knife_length = 23
if knife_length:
if knife_length <= 20:
print("刀的长度为%d厘米可以上车" % knife_length)
else:
print("刀的长度为%d厘米禁止上车" % knife_length)
else:
print("没有车票禁止上车")
#输出：刀的长度为23厘米可以上车
# 如果在开发程序时，不希望like编写分支内部的代码
# 可以使用 pass 关键字，表示一个占位符，能够保证程序的代码结果正确
# pass 就是一个空语句，不做任何事情
# 程序运行时，pass 关键字不会执行任何的操作
if a == b:
pass
else:
pass
逻辑运算
在程序开发中，通常在判断条件时，会需要同时判断多个条件
只有多个条件都满足，才能够执行后续代码，这个时候需要使用到逻辑运算符
逻辑运算符可以把多个条件按照逻辑进行连接，变化才能更复杂的条件
Python中的逻辑运算符包括：与and/h或or/非not三种
and
条件1 and 条件2
两个条件同时满足，返回True
只要有一个不满足，就返回False
or
条件1 or 条件2
两个条件只要有一个满足，返回True
两个条件都不满足，就返回False
not
not 条件
not True --> False
not False --> True
#案例1：定义一个整数变量 age，编写代码判断年龄是否正确
# 要求人的年龄在0-120之间
age = 120
if age >= 0 and age <= 120:
print("年龄正确")
else:
print("年龄错误")
#输出：年龄正确
#案例2：定义两个整数变量 python_score、c_sorce。编写代码判断成绩
# 只要有一门成绩>60分就算及格
python_score = 66
c_score = 59
if python_score > 60 or c_score > 60:
print("成绩合格")
else:
print("成绩不合格")
#输出：成绩合格
#案例3：定义一个布尔型型变量 is_employee,编写代码判断是否为本公司员工
#如果不是提示不允许入内
is_employee = True
if not is_employee:
print("非本公司人员,不允许入内")
#输出：非本公司人员,不允许入内
随机数的处理
在python中，要使用随机数，首先需要导入随机数的模块--"工具包"
import random
导入模块后，可以直接在模块名称后面敲一个"."然后按tab键，会提示该模块中包含的所有函数
random.randint(a,b),返回[a,b]之间的整数，包含a和b
# 生成随机数n：12 <= n <= 20 random.randint(12,20) # 结果永远是20 random.randint(20,20) # 该语句是错误的，下限必须小于等于上限 random.randint(20,10)
# 案例：剪刀石头布
# 从控制台输入要出的拳 -- 石头(1)/剪刀(2)/布(3)
# 规则：石头胜剪刀 剪刀胜布 布胜石头
# 电脑随机出拳 比较胜负
#从控制台输入想要拳 -- 石头(1)/剪刀(2)/布(3)
player = int(input("请输入您要出的拳:"))
#电脑随机出拳
import random
computer = random.randint(1,31)
print("玩家选择的拳是 %d - 电脑出的拳是 %d" % (player, computer))
#比较胜负
if (player == 1 and computer == 2)
or (player == 2 and computer == 3)
or (player == 3 and computer == 1):
print("玩家胜")
elif player == computer:
print("出拳相同")
else:
print("电脑胜")
循环
顺序 -- 从下向下，顺序执行代码
分支 -- 根据条件判断，决定执行代码的分支
循环 -- 让特定代码重复执行
while循环
while循环最常用的应用场景就是让执行的代码安置指定的次数重复执行
语法：
while 条件(判断 计数器 是否达到 目标次数):
条件满足时，做的事情1
条件满足时，做的事情2
条件满足时，做的事情3
...
处理条件(计数器 + 1)
注意：while语句以及缩进部分是一个完整的代码块
死循环：由于程序员忘记在循环内部修改循环的判断条件，导致循环持续执行，程序无法终止
#案例：打印5遍 Hello Python
# 定义一个整数变量，记录循环的次数
i = 0
#开始循环
while i < 5:
# 打印 Hello Python
print("Hello Python")
# 处理计数器
i = i + 1
赋值运算符
注意：赋值运算符中间不能使用空格
循环计算
在程序开发中，通常会遇到利用循环重复计算的需求
遇到这种需求，可以：
1.在while上方定义一个变量，用于存放最终计算结果
2.在循环体内部，每次循环都用最新的计算结果，更新之前定义的变量
# 案例：计算 0~100 之间所有数字的累计求和结果
# 定义一个最终结果的变量
result = 0
# 定义一个整数的变量记录循环的次数
i = 0
# 开始循环
while i <= 100:
print(i)
# 累加结果
result += i
# 处理计数器
i += 1
print(result) # 5050
##############################
# 案例：计算 0~100 之间所有偶数的累计求和结果
# 定义一个最终结果的变量
result = 0
# 定义一个整数的变量记录循环的次数
i = 0
# 开始循环
while i <= 100:
print(i)
# 累加结果
if i % 2 == 0:
result += i
# 处理计数器
i += 1
print(result) # 2550
break和continue
break和continue是专门在循环中使用的关键字
break某一条件满足时，退出循环
continue某一条件满足时，跳出本次循环
break和continue只针对当前所在的循环有效
循环嵌套
while 条件1:
条件1满足时，执行的代码
...
while 条件2:
条件2满足时，执行的代码
...
处理条件2
处理条件1
字符串中的转义字符
t 在控制台输出一个 制表符，协助在输出文本时 垂直方向保持对齐
n 在控制台输出一个换行符
print函数
print函数输出内容之后，会自动在内容末尾增加换行
如果不希望末尾增加换行，可以在print函数输出内容后面增加“,end=""”
# 向控制台输出内容结束之后，不会换行
print("aaaa", end="")
单纯的换行
print("")
# 案例:九九乘法表
i = 1
# 循环嵌套
while i <= 9:
j = 1
while j <= i:
# 计算乘积
result = i * j
print("%d * %d = %d" % (j, i, result), end="t")
# 处理计数器
j += 1
# 打印完一行之后换行操作
print("")
# 处理计数器
i += 1
函数
所谓函数，就是把就有独立功能的代码块组织为一个小模块，在需要的时候调用
函数的使用包含两个步骤：
1.定义函数 -- 封装独立的功能
2.调用函数 -- 享受封装的成果
函数的作用，在开发程序时，使用函数可以提高编写的效率以及代码的复用
语法：
def 函数名(形参列表):
函数封装的代码
...
def 是英文 define 的缩写
函数名称应该能够表达函数封装代码的功能，方便后续的调用
函数名称的命名应该符合 标识符的命名规则
可以由字母、下划线和数字组成
不能以数字开头
不能与关键字重名
能否将 函数调用 放在 函数定义 的上方呢？
不能！
因为在使用函数名调用函数之前，必须保证Python已经知道函数的存在
否则控制台提示 NameError:name '函数名' is not defined(名称错误:say_hello这个名字没有被定义)
PyCharm的调试工具
F8 Step Over 可以单步执行代码，会把函数调用看做是一行代码直接执行
F7 Step into 可以但不执行代码，如果是函数，会进入函数内部
Python中给函数添加文档注释
在定义函数的下方，使用连续的三对双引号
在连续的三对双引号之间编写对函数的说明文档
在函数调用位置，使用快捷键 ctrl + q 可以查看函数的说明信息
注意:因为 函数体相对比较独立，函数定义的商法，应该和其他代码(包括注释) 保留两个空行
参数的作用
函数，把具有独立功能的代码块 组织成为应该小模块，在需要的时候调用
函数的参数，增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据
在函数内部，把参数当做变量使用，进行需要的数据处理
函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递
形参和实参
形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数颞部作为变量使用
实参：调用函数时，小括号中的参数，是用来把数据传递到函数内部用的
函数的返回值
在程序开发中，有时候，会希望一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
返回值是函数完成工作后，最后给调用者的一个结果
在函数中使用 return 关键字可以返回结果
调用函数一方，可以使用变量来接收函数的返回结果
注意:return 表示返回，后续的代码都不会执行
name = "Tom"
# 定义一个函数
def say_hello():
"""打招呼"""
print("hello %s" % name)
print(name)
# 调用函数。只有主动调用函数，才会让函数执行
say_hello()
print(name)
# 定义求和函数
def sum(a, b):
"""对两个数字求和"""
result = a + b
print("%d + %d = %d" % (a, b, result))
# 返回求和结果
return result
# 调用函数,使用变量接返回的结果
num = sum(10, 20) # 30
print(num)
函数的嵌套调用
一个函数里面又调用了另外一个函数，这就是函数的嵌套调用
如果函数test2中，调用了另外函数test1
那么执行到调用test1函数时，会先把函数test1中的任务都执行完
才会回到test2中调用函数test1的位置，继续执行后续的代码
def test1():
print("test1")
def test2():
test1()
print("test2")
test2()
模块
模块是Python程序架构中的一个核心概念
模块就好比是工具包、想要使用这个工具包中的工具、就需要导入import这个模块
每一个以扩展名py结尾的Python源代码文件都是一个模块
在模块中定义的全局变量、函数都是模块能提供给外界直接使用的工具
可以在一个Python文件中定义变量或者函数
然后再另一个文件中使用import导入这个模块
导入之后，就可以使用 模块名.变量/模块名.函数 的方式，使用这个模块中定义的变量或者函数
模块可以让曾经编写过的代码方便的被复用！
模块名也是一个标识符
高级变量类型列表、元祖、字典、字符串、公共方法、变量高级
列表类型
list列表是Python中使用最频繁的数据类型，在其他语言中通常叫做数组
专门用于存储一串信息
链表用[]定义，数据之间使用 , 分隔
列表的索引从0开始
Python的列表中可以存储不同类型的数据
索引就是数据在列表中的位置编号，索引又可以被称为下标
注意：从列表中取值时，如果超出索引返回，程序会报错
# 定义一个列表
name_list = ["zhangsan", "xiaoming", "xiaohong"]
# 通过索引取值
name_zs = name_list[0]
name_xm = name_list[1]
name_xh = name_list[2]
# 知道数据的内容，想确定数据在列表中的位置
# 使用index方法需要注意，如果传递的数据不再列表中，程序会报错
index = name_list.index("xiaoming")
print(index) # 1
# 修改数据
name_list[2] = "kangkang"
print(name_list[2]) # kangkang
# 列表指定的索引超出范围，程序会报错！
# list assignment index out of range
# name_list[3] = "Tom"
# 向列表中增加数据
# 向列表的末尾追加数据
name_list.append("Jack")
print(name_list[3])
# 向指定索引位置插入数据
name_list.insert(1, "pgone")
print(name_list) # ['zhangsan', 'pgone', 'xiaoming', 'kangkang', 'Jack']
# 将 参数列表 中的数据追加到 当前列表 内
temp_list = ["aaa", "bbb", "ccc"]
name_list.extend(temp_list)
print(name_list) # ['zhangsan', 'pgone', 'xiaoming', 'kangkang', 'Jack', 'aaa', 'bbb', 'ccc']
# 删除列表中的指定数据
name_list.remove("zhangsan")
name_list.remove("aaa")
print(name_list) # ['pgone', 'xiaoming', 'kangkang', 'Jack', 'bbb', 'ccc']
# 不填参数时，删除列表中最后一条数据
name_list.pop()
print(name_list) # ['pgone', 'xiaoming', 'kangkang', 'Jack', 'bbb']
# 删除指定索引的数据，并且返回被删除的数据
name_pop = name_list.pop(3)
print(name_pop) # Jack
print(name_list) # ['pgone', 'xiaoming', 'kangkang', 'bbb']
# 也可以通过del删除指定索引数据
# del 关键字本质上是用来将一个变量从内存中删除
# 所以日常开发中，要从列表删除数据，建议使用列表提供的方法
del name_list[1]
print(name_list) # ['pgone', 'kangkang', 'bbb']
name_tmp = "pgtwo"
# 从内存中删除 name_tmp
del name_tmp
# 此时输出会报错
# NameError: name 'name_tmp' is not defined
# print(name_tmp)
# 清空列表
name_list.clear()
num_list = [11, 22, 3, 8, 22]
# len 获取列表的长度(统计列表中元素的总数)
list_len = len(num_list)
print(list_len) # 5
# cout 方法可以统计列表中某一个元素出现的次数
num_count = num_list.count("22")
print("22在列表中出现了%d次" % num_count) # xiaoming在列表中出现了2次
# 升序排序
num_list.sort()
print(num_list) # [3, 8, 11, 22, 22]
# 降序排序
num_list.sort(reverse=True)
print(num_list) # [22, 22, 11, 8, 3]
# 逆序(反转)
num_list.reverse()
print(num_list) # [3, 8, 11, 22, 22]
循环遍历
遍历就是从头到尾依次从列表中获取数据
在循环体内部针对每一个元素，执行相同的操作
在Python中为了提高列表的遍历效率，专门提供了迭代iteration遍历
使用芙蓉实现迭代遍历
# for 循环内部使用的变量 in 列表 for name in name_list: # 循环内部针对列表元素进行操作 print(name)元组
Tuple(元组) 与列表类似，不同之处在于元组的元素不能修改
元组表示多个元素组成的序列
元组在Python中，有特定的应用场景
用于存储一串信息，数据之间使用","分隔
元组使用"()"定义
元组的索引从0开始
索引就是数据在元组中的位置编号
# 创建一个元组
info_tuple = ("zhangsan", 18, 1.75)
type(info_tuple) # tuple
name = info_tuple[0] # zhangsan
age = info_tuple[1] # 18
high = info_tuple[2]
# 创建一个空元组
empty_tuple = ()
# 元组中只写一个元素 类型是元素的类型，不是tuple
single_tuple = (5)
type(single_tuple) # int
# 定义一个只有一个元素的元组
tuple_one = (30, )
type(tuple_one) # tuple
# 定义一个元组
info_tuple = ("Tom", 18, 1.75, "Tom")
# 取值和取索引
# 取值
print(info_tuple[0]) # Tom
# 取索引 (已经知道数据的内容，希望知道该数据在元组中的索引)
print(info_tuple.index("Tom")) # 0
# 统计次数
print(info_tuple.count("Tom")) # 2
# 循环遍历元组
for ele in info_tuple:
print(ele)
元组在开发中的应用场景
函数的参数和返回值，一个参数可以接受任意多个参数，或者一次返回多个数据
格式字符串，格式化字符串后面的() 本质上就是一个元组
让列表不可以被修改，保护数据的安全
# 格式化字符串后面的 '()' 本质上就是元组
info_tuple2 = ("Jack", 18, 1.90)
print("%s 年龄是 %d 身高是 %.2f m" % ("Jack", 18, 1.90)) # Jack 年龄是 18 身高是 1.90 m
print("%s 年龄是 %d 身高是 %.2f m" % info_tuple2) # Jack 年龄是 18 身高是 1.90 m
元组和列表之间的转换
使用list函数可以把元组转换成列表
list(元组)
使用tuple函数可以把列表转换成元组
tuple(列表)
num_list = [1, 2, 3, 4] print(type(num_list)) #字典# 将list转换成tuple list_to_tuple = tuple(num_list) print(type(list_to_tuple)) # # 再讲tuple转换成list tuple_to_list = list(list_to_tuple) print(type(tuple_to_list)) #
dictionary(字典) 是除列表以外Python中最灵活的数据类型
字典同样可以用来存储多个数据
通常用于存储描述一个物体的相关信息
字典和列表的区别
列表是有序的对象集合
字典是无序的对象集合
字典用{}定义
字典使用键值对存储数据，键值之间使用,分隔
键key是索引
键value是数据
键和值之间使用:分隔
键必须是唯一的
值可以取任何数据类型，但键只能使用字符串、数字或者元组
遍历字典
遍历就是以此从字典中获取键值对
for key in 字典:
针对字典单个元素操作
循环遍历取出的是键值对的key
应用场景
尽管可以使用for in遍历字典
但是开发中，更多的应用场景是：
使用多个键值对，存储描述一个物体的相关信息 -- 描述更复杂的数据信息
将多个字典放在一个列表中，再进行遍历，在循环体内部针对每一个字典进行相同的处理
# 定义一个字典
tom = {"name": "Tom",
"age": 18,
"gender": "男",
"height": "1.75"}
# 字典是一个无序的数据集合，使用print函数输出字典时
# 通常输出的顺序和定义的顺序是不一致的
print(tom)
# 取值
print(tom["name"]) # Tom
print(tom["height"]) # 1.75
# 取不存在的key时会报错
# KeyError: 'name11'
# print(tom["name11"])
# 修改
tom["age"] = 19
print(tom["age"]) # 19
# 增加
# 如果key不存在就会增加一条键值对
tom["weight"] = 180
print(tom) # {'name': 'Tom', 'age': 19, 'gender': '男', 'height': '1.75', 'weight': 180}
# 删除
tom.pop("height")
print(tom) # {'name': 'Tom', 'age': 19, 'gender': '男', 'weight': 180}
# 如果指定的key值不正确会报错
# KeyError: 'name11'
# tom.pop("name33")
# 统计键值对的数量
count = len(tom)
print(count)
# 合并字典 将另外一个字典数据合并到当前字典中
# 如果当前字典中已经有另外一个字典的key，会覆盖原有的键值对的数据
letter_dir = {"aa": "AA",
"bb": "BB",
1: "111"}
num_dir = {1: "one",
2: "two"}
letter_dir.update(num_dir)
print(letter_dir) # {'aa': 'AA', 'bb': 'BB', 1: 'one', 2: 'two'}
# 循环遍历
for k in tom:
print((k, tom[k]))
# 清空字典
letter_dir.clear()
# 使用多个键值对，存储 描述一个 物体 的相关信息 -- 描述更复杂的数据信息
# 将多个字典放在一个列表中，再进行遍历
card_list = [
{"name": "张三",
"qq": "145769",
"phone": "17777"},
{"name": "李四",
"qq": "295686",
"phone": "19999"},
{"name": "狗蛋",
"qq": "988444",
"phone": "12222"}
]
for ele in card_list:
print(ele)
"""
{'name': '张三', 'qq': '145769', 'phone': '17777'}
{'name': '李四', 'qq': '295686', 'phone': '19999'}
{'name': '狗蛋', 'qq': '988444', 'phone': '12222'}
"""
字符串
字符串就是一串字符，是编程语言中表示文本的数据类型
在Python总可以使用一对双引号""或者一对单引号''定义一个字符串
虽然可以使用"或者'做字符串的转义，但是在实际开发中
如果字符串内部需要使用",可以使用'定义字符串
如果字符串内部需要使用',可以使用"定义字符串
可以使用索引获取一个字符串指定位置的字符，索引位置从0开始
也可以使用for循环遍历字符串中每一个字符
大多数编程语言都是使用"来定义字符串
hello_str = "hello hello"
# 统计字符串的长度
print(len(hello_str)) # 11
# 统计某一个小(子)字符串出现的次数
str_count = hello_str.count("hel")
print(str_count) # 2
print(hello_str.count("abc")) # 0
# 某个子字符串出现的位置
str_index = hello_str.index("llo")
print(str_index) # 2
# 设置一个不存在的字符串会报错
# ValueError: substring not found
# print(hello_str.index("abc"))
判断类：
# 判断空白符 str1 = " " str2 = " r" str3 = " t" str4 = " n" str5 = " aa" print(str1.isspace()) # True print(str2.isspace()) # True print(str3.isspace()) # True print(str4.isspace()) # True print(str5.isspace()) # False # 判读字符串中是否只包含数字 num_str = "1" num_str2 = "1.1" print(num_str.isdecimal()) # True print(num_str.isdigit()) # True print(num_str.isnumeric()) # True # 以上三个方法都不能判断小数 print(num_str2.isdecimal()) # False print(num_str2.isdigit()) # False print(num_str2.isnumeric()) # False # unicode 字符串 num_str3 = "(1)" # unicode 字符串 u转义之后输出一个平方字符串 ² num_str4 = "u00b2" print(num_str4) print(num_str3.isdecimal()) # False print(num_str3.isdigit()) # True print(num_str3.isnumeric()) # True # 中文数字 num_str5 = "一千零一" print(num_str5.isdecimal()) # False print(num_str5.isdigit()) # False print(num_str5.isnumeric()) # True
查找替换类：
hello_str = "hello world"
# 判断是否以指定字符串开始
print(hello_str.startswith("hello")) # True
print(hello_str.startswith("Hello")) # False
# 判断是否以指定字符串结束
print(hello_str.endswith("ld")) # True
# 查找指定字符串
# index同样可以查找指定的字符串在大字符串中的索引
str_index = hello_str.find("llo")
print(str_index) # 2
# index如果指定的字符串不存在，会报错
# find如果指定的字符串不存在，不会报错，返回一个 -1
print(hello_str.find("abc")) # -1
# 替换字符串
rep_str = hello_str.replace("world", "Python")
print(rep_str) # hello Python
# replace方法执行完成之后，会返回一个新的字符串
# 不会修改原有字符串的内容
print(hello_str) # hello world
大小写转换：
文本对齐：
# 假设：以下内容是从网络上抓取的
# 要求：顺序并且居中对齐输出以下内容
poem = ["登鹳雀楼",
"王之涣",
"白日依山尽",
"黄河入海流",
"欲穷千里目",
"更上一层楼"]
for poem_str in poem:
# 不加fillchar参数 默认使用英文的空格
print("|%s|" % poem_str.center(10," "))
"""
| 登鹳雀楼 |
| 王之涣 |
| 白日依山尽 |
| 黄河入海流 |
| 欲穷千里目 |
| 更上一层楼 |
"""
去除空白符：
# 假设：以下内容是从网络上抓取的
# 要求：顺序并且居中对齐输出以下内容
poem = ["tn登鹳雀楼",
"王之涣",
"白日依山尽tn",
"黄河入海流",
"欲穷千里目",
"更上一层楼"]
for poem_str in poem:
# 先使用strip方法去除字符串中的空白字符
# 再使用center方法居中对齐
print("|%s|" % poem_str.strip().center(10," "))
"""
| 登鹳雀楼 |
| 王之涣 |
| 白日依山尽 |
| 黄河入海流 |
| 欲穷千里目 |
| 更上一层楼 |
"""
拆分和连接：
# 假设：以下内容是从网络上抓取的 # 要求： # 1. 将字符串中的空白字符全部去掉 # 2. 再使用" "作为分隔符，拼接一个整齐的字符串 poem_str = "登鹳雀楼t王之涣t白日依山尽tt黄河入海流tn欲穷千里目t更上一层楼" # 拆分字符串,不填参数默认是空格为分隔符 poem_list = poem_str.split() # 合并字符串 result = " ".join(poem_list) print(result) # 登鹳雀楼 王之涣 白日依山尽 黄河入海流 欲穷千里目 更上一层楼字符串的切片
切片方法适用于字符串、列表、元组
切片使用索引值来限定范围，从一个大的字符串中切出小的字符串
列表和元组都是有序的集合，都能够通过索引值，获取到对应的数据
字典是一个无序集合，是使用键值对保存数据
字符串[开始索引:结束索引:步长]
num_str = "0123456789" # 切片截取2345 num_str_split1 = num_str[2:6] print(num_str_split1) # 切片截取2到末尾的字符串 num_str_split2 = num_str[2:] # 2345 print(num_str_split2) # 23456789 # 切片截取012345 num_str_split3 = num_str[0:6] print(num_str_split3) # 012345 # 从首位开始，首位索引也可以省略 num_str_split4 = num_str[:6] print(num_str_split4) # 012345 # 截取完整的字符串 num_str_split5 = num_str[:] print(num_str_split5) # 0123456789 # 从开始位置，每隔一个字符截取字符串 num_str_split6 = num_str[::2] print(num_str_split6) # 02468 # 从索引1开始每隔一个字符截取字符串 num_str_split7 = num_str[1::2] print(num_str_split7) # 13579 # 截取从 2 ~ 末尾 -1 的字符串 num_str_split8 = num_str[2:-1] print(num_str_split8) # 2345678 # 截取末尾两个字符 num_str_split9 = num_str[-2:] print(num_str_split9) # 89 # 字符串的逆序 num_str_split10 = num_str[-1::-1] print(num_str_split10) # 9876543210公共方法
Python内置函数
Python包含了以下内置函数
a = [1, 2, 3]
# 删除 del
del a[1]
print(a) # [1, 3]
del(a[1])
print(a) # [1]
# max最大值
t_str = "dsfafzflanvzpqmzoqn"
print(max(t_str)) # z
t_dict = {"a": "z", "b": "y", "c": "x"}
print(max(t_dict)) # c
# min最小值
t_list = [4, 5, 1, 7, 9]
print(min(t_list)) # 1
print(min(t_dict)) # a
# 比较
print("1" < "2") # True
print("1" > "2") # False
print("baaa" < "accc") # False
print([1, 1, 1] < [2, 2, 2]) # True
print([1, 1, 9] < [1, 2, 1]) # True
print((1, 3, 5) < (2, 1, 1)) # True
切片
切片使用索引值来限定范围，从一个大的字符串中切出小的字符串
列表和元组都是有序的集合，都能够通过索引值获取到对应的数据
字典是一个无序的集合，是使用键值对保存数据
num_list = [0, 1, 2, 3, 4]
print(num_list[1:3]) # [1, 2]
num_tuple = (0, 1, 2, 3, 4)
print(num_tuple[1:3]) # [1, 2]
num_dict = {"a": "a", "b": "b", "c": "c"}
# 字典是不能切片的
# TypeError: unhashable type: 'slice'
# print(num_dict[1:2])
运算符
t_str1 = "abc"
print(t_str1 * 2) # abcabc
t_str2 = "def"
print(t_str1 + t_str2) # abcdef
t_list1 = [1, 2]
print(t_list1 * 3) # [1, 2, 1, 2, 1, 2]
t_list2 = [3, 4]
print(t_list1 + t_list2) # [1, 2, 3, 4]
# extend 会将列表参数合并到当前列表末尾
# t_list1.extend([5, 6]) # [1, 2, 5, 6]
# append 会将列表参数整个追加到当前列表末尾
# t_list1.append([5, 6]) # [1, 2, [5, 6]]
t_tuple1 = (1, 2)
print(t_tuple1 * 3) # (1, 2, 1, 2, 1, 2)
t_tuple2 = (3, 4)
print(t_tuple1 + t_tuple2) # (1, 2, 3, 4)
t_dict1 = {1: 2, 3: 4}
# 字典无法使用运算符 因为字典中key是唯一的
# TypeError: unsupported operand type(s) for *: 'dict' and 'int'
# print(t_dict1 * 3)
print("a" in "abcd") # True
print("a" not in "abcd") # False
print(6 in [1, 2, 3]) # False
print(6 not in [1, 2, 3]) # True
print(6 in (1, 2, 3)) # False
print(6 not in (1, 2, 3)) # True
print("a" in {"a": "b"}) # True
print("b" in {"a": "b"}) # False
完整的for循环语法
(else后的代码只有循环遍历完成才会执行)
for 变量 in 集合:
循环体代码
else:
没有通过break退出循环，循环结束后，会执行的代码
for num in [1, 2, 3]:
print(num)
else:
print("else代码块执行")
print("循环结束！")
"""
1
2
3
else代码块执行
循环结束！
"""
应用场景
在迭代遍历嵌套数据类型时，例如一个列表包含了多个字典
需求：要判断某个字典总是否存在指定的值
如果存在，提示并且推出循环
如果不存在，在循环整体结束后，希望得到一个统一的提示
students = [
{"name": "Tom",
"age": 20,
"gender": True,
"height": 1.7,
"weight": 75.0},
{"name": "Jack",
"age": 21,
"gender": True,
"height": 1.69,
"weight": 62.0},
{"name": "Jan",
"age": 19,
"gender": False,
"height": 1.61,
"weight": 48},
]
find_name = "Tom"
for student in students:
if student["name"] == find_name:
print(student)
print("找到了 %s" % find_name)
# 如果已经找到了退出循环
break
else:
print("没有找到 %s" % find_name)
print("循环结束")
Linux上的Shebang符号(#!)
#! 这个符号叫做Shebang或者Sha-bang
Shebang通常在Unix系统脚本当中 第一行开头 使用
指明执行这个脚本文件的 解释程序
使用which查询 python3解释器所在路径
$ which python3
修改要运行的主python文件，在第一行增加以下内容
#! /usr/bin/python3
修改主python文件的文件权限，增加执行权限
$ chmod +x cards_main.py
需要时候执行程序即可
./cards_main.py变量进阶
变量的引用
可变和不可变类型
局部变量和全局变量
变量的引用
变量和数据都是保存在内存中的
在Python中函数的参数传递以及返回值都是靠引用传递的
引用的概念
在python中
变量和数据是分开存储的
数据保存在内存中的一个位置
变量中保存着数据在内存中的地址
变量中记录数据的地址，就叫做引用
使用id()函数可以查看变量中保存数据所在的内存地址
注意：如果变量已经被定义，当给一个变量赋值的时候，本质是修改了数据的引用
变量不再对之前的数据引用
变量改为对新赋值的数据引用
可变和不可变类型
不可变类型，内存中的数据不允许被修改
数字类型 int,bool,float,complex,long(2.x)
字符串 str
元组 tuple
可变类型，内存中数据可以修改
列表 list
字典 dict
注意：字典的key只能使用不可变类型的数据
a = 1 b = a # 查看引用地址 print(id(a)) # 140735129753248 print(id(b)) # 140735129753248
def test(num):
print("在函数内部 %d 对应的内存你地址是 %d" % (num, id(num)))
# 定义一个字符串变量
result = "hello python"
print("函数要返回的内存地址是 %d" % id(result)) # 函数要返回的内存地址是 2136352053040
# 将字符串变量返回
# 字符串变量返回，返回的是数据的引用，而不是数据本身
return result
# 定义一个数字的变量
a = 10
# 数据的地址本质上就是一个数字
print("a变量保存的内存地址是 %d" % id(a)) # a变量保存的内存地址是 140735126935488
# 调用test函数
# 本质上传递的是实参保存数据的引用，而不是实参保存的数据本身
addr = test(a) # 在函数内部 10 对应的内存你地址是 140735126935488
print("返回值的内存地址是 %d" % id(addr)) # 返回值的内存地址是 2136352053040
num_list = [1, 2, 3, 99]
print(id(num_list)) # 1519488404352
num_list.remove(2)
print(id(num_list)) # 1519488404352
num_list = []
print(id(num_list)) # 1610252121536
name_dict = {"name": "小明"}
print(id(name_dict)) # 1857927780224
name_dict.pop("name")
print(id(name_dict)) # 1857927780224
name_dict["name"] = "小美"
print(id(name_dict)) # 1857927780224
注意:
可变类型的数据变化，是通过方法来实现的
如果给一个可变类型的变量，赋值了一个新的数据，引用会修改
变量不再对之前的数据引用
变量改为对新赋值的数据引用
哈希:
Python中内置有一个名字叫做hash(o)的函数
接收一个不可变类型的数据作为参数
返回结果是一个整数
哈希是一种算法，其作用就是提取数据的特征码(指纹)
相同的内容得到相同的结果
不同的内容得到不同的结果
在Python中，设置字典的键值对时，会首先对key进行hash已决定如何在内存中保存字典的数据，以方便后续对字典的操作：增、删、改、查
键值对的key必须是不可变类型数据
键值对value可以是任意类型的数据
局部变量是在函数内部定义的变量，只能在函数内部使用
全部变量是在函数外部定义的变量(没有定义在某一个函数内)，所有函数内部都可以使用这个变量
提示：在其他语言中，大多不推荐使用全局变量--可变范围太大，导致程序不好维护
局部变量
局部变量是在函数内部定义的变量，只能在函数内部使用
函数执行结束后，函数内部的局部变脸，会被系统回收
不同的函数，可以定义相同的名字的局部变量，但是各用各的不会产生影响
局部变量的作用
在函数内部使用，临时保存函数内部需要使用的数据
局部变量的生命周期
所谓生命周期就是变量从被创建到被系统回收的过程
局部变量在函数执行时才会被创建
函数执行结束后局部变量被系统回收
局部变量在生命周期内，可以用来存储函数内部临时使用到的数据
全局变量
全局变量是在函数外部定义的变量，所有函数内部都可以使用这个变量
注意：函数执行时，需要处理变量时会：
1.首先查找函数内部是否存在指定名称的局部变量，如果有，直接使用
2.如果没有，查找函数外部是否存在指定名称的全局变量，如果有，直接使用
3.如果还没有，程序报错
函数不能直接修改全局变量的引用
全局变量是在函数外部定义的变量(没有定义在某一个函数内)，所有函数内部都可以使用这个变量
在函数内部，可以，可以通过全局变量的应用获取对应的数据
但是，不允许直接修改全局变量的引用 -- (不能使用赋值语句修改全局变量的值)
使用global声明一下变量，就可以在函数内部修改全局变量值
全局变量定义的位置
为了保证所有的函数都能正确使用到全局变量，应该讲全局变量定义在其他函数的上方
全局变量的命名建议
为了避免局部变量和全局变量出现混淆，在定义全局变量时，有些公司会有有些开发要求
全局变量名前应该增加 g_ 或者 gl_ 的前缀
# 全局变量
num = 10
def demo01():
# 希望修改全局变量的值
# 在 python 中，是不允许直接修改全局变量的值
# 如果使用赋值语句，会在函数内部，定义了一个局部变量
num = 99
print("demo01 ==> %d" % num)
def demo02():
print("demo02 ==> %d" % num)
def demo03():
# 使用global声明一下变量即可
# global 关键字会告诉解释器后面的变量是一个全局变量
global num
# 使用赋值语句，就不会创建局部变量
num = 100
print("demo03 ==> %d" % num)
demo01() # demo01 ==> 99
demo02() # demo02 ==> 10
demo03() # demo03 ==> 100
函数
函数的参数和返回值
函数根据有没有参数以及有没有返回值，可以相互结合，一共有4中组合形式
1.无参数，无返回值
2.有参数，有返回值
3.有参数，无返回值
4.有参数，有返回值
返回值
返回值是函数完成工作后，最后给调用者的一个结果
在函数中使用return关键字可以返回结果
调用函数一方，可以使用变量来接收函数的返回结果
问题：一个函数执行后能否返回多个结果
# 定义一个函数
def measure():
""""测量温度和湿度"""
print("测量开始...")
temp = 39
wetness = 50
print("测量结束...")
# 元组-可以包括多个数据，因此可以使用元组让函数返回多个值
# 如果函数返回值类型是元组，小括号可以省略
# return (temp, wetness)
return temp, wetness
# result类型是元组
result = measure()
print(type(result)) #
print(result) # (39, 50)
print(result[0]) # 39
print(result[1]) # 50
# 如果函数返回的类型是元组，同时希望单独处理元组中的元素
# 可以使用多个变量，一次接受函数的返回值
# 注意：使用多个变量接收结果时，变量的个数应该和元组中元素的个数保持一致
gl_temp, glwetness = measure()
print(gl_temp) # 39
print(glwetness) # 50
交换两个数字
# 有两个整数变量 a = 6, b = 100 # 不使用其他变量，交换两个变量的值 b = 100 a = 6 # 方法1：使用临时变量 c = b b = a a = c # 方法2: 不使用临时变量 a = a + b b = a - b a = a - b # 方法3：Python专有，利用元祖 # a, b = (b, a) a, b = b, a
函数参数进阶
不可变和可变参数
在函数内部，针对参数使用赋值语句，不会影响调用函数时传递的实参变量
只要针对参数使用赋值语句，会在函数内部修改局部变量的引用，不会影响到外部变量的引用
def demo(num):
print("函数内部代码")
# 在函数内部，针对参数使用赋值语句
# 不会修改到外部的实参变量
num = 100
print(num)
print("函数执行完成")
gl_num = 99
demo(gl_num) # 100
print(gl_num) # 99
如果传递的参数是可变类型，在函数内部，使用方法修改了数据的内容，同样会影响到外部的数据
def demo(num_list):
print("函数内部的代码")
# 使用方法修改列表的内容
num_list.append(9)
print(num_list)
print("函数执行完成")
gl_list = [1, 2, 3]
demo(gl_list)
print(gl_list) # [1, 2, 3, 9]
在python中，列表变量调用 += 本质上执行列表变量的 extend 方法，不会修改变量的引用
def demo(num, num_list):
print("函数内部代码")
# num = num + num
num += num
print(num) # 18
# 列表变量使用 + 不会相加再赋值的操作
# num_list = num_list + num_list
# += 本质上在调用列表的 extend 方法
# num_list.extend(num_list)
num_list += num_list
print(num_list) # [1, 2, 3]
print("函数完成")
gl_num = 9
gl_list = [1, 2, 3]
demo(gl_num, gl_list)
print(gl_num) # 9
print(gl_list) # [1, 2, 3, 1, 2, 3]
缺省参数
定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省参数
调用函数时，如果没有传入缺省参数的值，则在函数内部使用定义函数时指定的参数默认值
函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用
例如：对列表排序的方法
gl_num_list = [6, 3, 9] # gl_num_list.sort(self, key, reverse) # 如果不传参数默认按照升序 gl_num_list.sort() # 传入reverse参数变为降序 gl_num_list.sort(reverse=True)
def print_info(name, gender=True):
"""
:param name:同学的姓名
:param gender:True男生 False女生
"""
gender_text = "男生"
if not gender:
gender_text = "女生"
print("%s 是 %s" % (name, gender_text))
# 指定缺省参数的默认值时，应该使用最常见的值作为默认值
print_info("小明") # 小明 是 男生
print_info("小美", False) # 小美 是 女生
缺省参数的注意事项
缺省参数的定义位置
必须保证带有默认值的缺省参数在参数列表的末尾
# 错误定义方法 def print_info(name, gender=True,title):
调用带有多个缺省参数的函数
在调用函数时，如果有多个缺省参数，需要指定参数名，这样解释器才能够做到参数对应的关系
def print_info(name, title="学生", gender=True):
"""
:param title:职位
:param name:同学的姓名
:param gender:True男生 False女生
"""
gender_text = "男生"
if not gender:
gender_text = "女生"
print("【%s】%s 是 %s" % (title, name, gender_text))
print_info("小明") # 小明 是 男生
# 有多个缺省参数时候，要指定参数名，不然解释器无法准确识别参数
print_info("小美", False) # 【False】小美 是 男生
print_info("小美", gender=False) # 【学生】小美 是 女生
多值参数
定义支持多值参数的函数
有时可能需要一个函数能够处理参数个数是不确定的，这个时候，就可以使用多值参数
python中有两种多值参数
参数名前增加一个 * 可以接收元组
参数名前增加两个 * 可以接收字典
一般在给多值参数命名时，相关使用以下两个名字
*args -- 存放元组参数，前面有一个 *
**kwargs -- 存放字典参数，前面有两个 *
args是arguments的缩写，有变量的含义
kw是keyword的缩写，kwargs可以记忆 键值对参数
def demo(num, *args, **kwargs):
print(num)
print(args)
print(kwargs)
demo(1, 2, 3, 4, 5, name="小明", age=18, gender=True)
"""
1
(2, 3, 4, 5)
{'name': '小明', 'age': 18, 'gender': True}
"""
# 多值参数案例 -- 计算任意多个数字的和
# 定义一个函数sum_numbers，可以接收的任意多个整数
def sum_numbers(*args):
num = 0
# 遍历 args 元组求和
for n in args:
num += n
print(num)
sum_numbers(1, 2, 3, 4, 5) # 15
元组和字典的拆包
在调用带有多值参数的函数时，如果希望：
将一个元组变量，直接传递给args
将一个字典变量，直接传递给kwargs
就可以使用拆包，简化参数的传递，拆包的方式是：
在元组变量前，增加一个*
在字典变量钱，增加两个*
def demo(*args, **kwargs):
print(args)
print(kwargs)
gl_nums = (1, 2, 3, 4)
gl_xiaoming = {"name": "xiaoming", "age": 18}
# 传递参数，调用函数
demo(gl_nums, gl_xiaoming)
"""
((1, 2, 3, 4), {'name': 'xiaoming', 'age': 18})
{}
"""
# 拆包语法简化元组变量/字典变量的传递
demo(*gl_nums, **gl_xiaoming)
"""
(1, 2, 3, 4)
{'name': 'xiaoming', 'age': 18}
"""
函数的递归
函数调用自身的编程技巧称为递归
递归函数的特点
特点
一个函数内部调用自己
函数内部可以调用其他函数，当然在函数内部也可以调用自己
代码特点
函数内部的代码是相同的，只是针对参数不同，处理的结果不同
单参数满足一个条件时，函数不在执行
这个非常重要，通常称为递归的出口，否则会出现死循环
# 定义一个递归求 1~100的和
def sum_number(num):
if num == 1:
return 1
return num + sum_number(num - 1)
sum = sum_number(100)
print(sum) # 5050
