Python入门笔记

第一章. Python简介

1.1 Python官网

Python官网

1.2 Python发展历史

Python发展历史

1.3 Python版本

Python 2.X
Python 3.X
Python 3.5
Python 3.6
Python 3.7
注意：课程讲解Python 3.7

1.4 解释器的作⽤

• Python解释器作⽤：运⾏⽂件
• Python解释器种类:
  • CPython，C语⾔开发的解释器[官⽅]，应⽤⼴泛的解释器。
  • IPython，基于CPython的⼀种交互式解释器。
• 其他解释器
  • PyPy，基于Python语⾔开发的解释器。
  • Jython，运⾏在Java平台的解释器，直接把Python代码编译成Java字节码执⾏。
  • IronPython，运⾏在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码
    课程中使⽤的解释器：CPytho

1.5 下载Python解释器

• 下载地址

[单击下载] – 查找⽬标⽂件：Windows x86-64 executable installer – 单击即可下载。

1.6 安装Python解释器

• 双击可执⾏⽂件 — 勾选[pip] – [Next] – [勾选添加环境变量] – [Install]，按提示操作即可。
  

1.7 PyCharm的作⽤

PyCharm是⼀种Python IDE（集成开发环境），带有⼀整套可以帮助⽤户在使⽤Python语⾔开发时提⾼其效率的⼯具，内部集成的功能如下

• Project管理
• 智能提示
• 语法⾼亮
• 代码跳转
• 调试代码
• 解释代码(解释器)
• 框架和库
  …

PythonCharm分为专业版（professional）和社区版（community），笔记以社区版为基准进⾏操作和讲解。

1.8 下载和安装

1.8.1 下载

PythonCharm下载地址

• 专业版(付费)
  
• 社区版
  

1.8.2 安装

• 双击安装包 – [运⾏] – [允许你应⽤更改设备]: [是] – [Next] – [选择安装位置] – [Next] – [Install] --[Finish]。

1.9 PyCharm基本使⽤

1.9.1 新建项⽬

• 打开PyCharm – [Create New Project] – 选择项⽬根⽬录和解释器版本 – [Create]，即可完成新建⼀个项⽬。
  

1.9.2 新建文件

• 项⽬根⽬录或根⽬录内部任意位置 — 右键 – [New] – [Python File] – 输⼊⽂件名 – [OK]

• 如果是将来要上传到服务器的⽂件，那么⽂件名切记不能⽤中⽂。

双击打开⽂件，并书写⼀个最简单的Python代码:

print("hello world")

1.9.3 运⾏⽂件

• ⽂件打开状态 – 空⽩位置 — 右键 – Run – 即可调出Pycharm的控制台输出程序结果。
  

1.9.4 PyCharm的基本设置

• [file] – [Settings]/[Default Settings]
  

1.9.5 修改主题

• [Appearance & Behavior] – [Appearance]
  

• Theme：修改主题
• Name：修改主题字体
• Size：修改主题字号

1.9.6 修改代码⽂字格式

[Editor] – [Font]

• Font：修改字体
• Size：修改字号
• Line Spacing：修改⾏间距

1.9.7 修改解释器

[Project: 项⽬名称] – [Project Interpreter] – [设置图标] – [Add] – 浏览到⽬标解释器 – [OK] --[OK]。

第二章. Python基本语法

2.1 注释的分类及语法

注释分为两类：单⾏注释 和 多⾏注释。

• 单⾏注释
  只能注释⼀⾏内容，语法如下：

# 注释内容

• 多⾏注释
  可以注释多⾏内容，⼀般⽤在注释⼀段代码的情况， 语法如下：

"""
 第⼀⾏注释
 第⼆⾏注释
 第三⾏注释
"""
'''
 注释1
 注释2
 注释3
'''

快捷键： ctrl + /

2.2 快速体验

• 单⾏注释

# 输出hello world
print('hello world')
print('hello Python') # 输出(简单的说明可以放到⼀⾏代码的后⾯，⼀般习惯代码后⾯添加
两个空格再书写注释⽂字)

• 多⾏注释

"""
 下⾯三⾏都是输出的作⽤，输出内容分别是：
 hello Python
 hello itcast
 hello itheima
"""
print('hello Python')
print('hello itcast')
print('hello itheima')
'''
 下⾯三⾏都是输出的作⽤，输出内容分别是：
 hello Python
 hello itcast
 hello itheima
'''
print('hello Python')
print('hello itcast')
print('hello itheima')

注意：解释器不执⾏任何的注释内容。

总结

• 注释的作⽤
  ⽤⼈类熟悉的语⾔对代码进⾏解释说明，⽅便后期维护。
• 注释的分类
  • 单⾏： # 注释内容 ，快捷键ctrl+/
  • 多⾏： “”" 注释内容 “”" 或 ‘’’ 注释内容 ‘’’

2.3 变量的作用

程序中，数据都是临时存储在内存中，为了更快速的查找或使⽤这个数据，通常我们把这个数据在内存中存储之后定义⼀个名称，这个名称就是变量。

变量就是⼀个存储数据的的时候当前数据所在的内存地址的名字⽽已。

2.4 定义变量

变量名 = 值
变量名⾃定义，要满⾜标识符命名规则。

2.5 标识符

pyhon中，标识符命名的规则组要有三类：

• 内容限定
• 大小写敏感
• 不可使用关键字

标识符命名规则是Python中定义各种名字的时候的统⼀规范，具体如下：

• 由数字、字⺟、下划线组成
• 不能数字开头
• 不能使⽤内置关键字
• 严格区分⼤⼩写

标识符命名中，只允许出现

• 英文
• 中文 (不推荐使用中文)
• 数字 (数字不可用开头)
• 下划线(_)

标识符中的关键字，如下:

False	 None	 True 	and 	as 	assert 	break 	class 
continue 	def 	del 	elif 	else 	except 	finally 	for
from 	global 	if 	import 	in 	is 	lambda 	nonlocal
not 	or 	pass 	raise 	return 	try 	while 	with yield

"""
什么是标识符?
    在pthon程序中,我们可以给很多东西起名字,比如
        * 变量的名字
        * 方法的名字
        * 类的名字,等等
    这些名字,我们把它统一的称之为表标识符,用来做内容的标识.
    所以,标识符: 是用户在编程的时候所使用的一系列名字,用于给变量,类,方法等命名.

python中,标识符的命名规则主要有3类:
    * 内容限制
    * 大小写敏感
    * 不可使用关键字
标识符命名中,只允许出现:
    * 英文
    * 中文(不推荐使用中文)
    * 数字(数字不可用开头)
    * 下划线(_)
这四类原始.其余任何内容都不允许出现.关键字也不可以作为标识符.
"""

# 规则1: 内容限定,限定只能使用:中文,英文,数字,下划线,注意:不能一数字开头
# 1_name = "张三"; #错误的代码示范
# name_! = "张三"; #错误的代码示范
name_ = "张三";
_name = "张三";
name_1 = "张三";

# 规则2: 大小写敏感
Itheima = "黑马程序员";
itheima = "hello world";
print(Itheima);
print(itheima);

# 规则3: 不可以使用关键字
# class = 1; #醋味的示例
# def = 1; #错误的示例
Class = 1; #因为区分大小写,所以不属于关键字,是合法的命名

"""
变量命名规范:
    学完了标识符(变量,类,方法)的命名规则后,我们来学习标识符的命名规范.
        * 变量名
        * 类名
        * 方法名
    不同的标识符,有不同的规范.
    我们目前只接触到了变量.所以目前学习:变量的命名规范.
        * 见名知意
        * 下划线命名法(多个单词组合变量名,要使用下划线做分割)
        * 英文字母全小写
"""

2.6 命名习惯

• ⻅名知义。
• ⼤驼峰：即每个单词⾸字⺟都⼤写，例如： MyName 。
• ⼩驼峰：第⼆个（含）以后的单词⾸字⺟⼤写，例如： myName 。
• 下划线：例如： my_name 。

2.7 使用变量

# 定义一个变量,用来记录钱包余额
money = 50;
# 通过print语句,输出变量记录的内容
print("钱包还有:",money,"元");

# 买了一个冰淇淋,花费了10元
money = money - 10;
print("买了冰淇淋,还剩余:",money,"元");

2.8 认识bug

所谓bug，就是程序中的错误。如果程序有错误，需要程序员排查问题，纠正错误。

2.9 debug工具

Debug⼯具是PyCharm IDE中集成的⽤来调试程序的⼯具，在这⾥程序员可以查看程序的执⾏细节和流程或者调解bug。

Debug⼯具使⽤步骤：

• 打断点
• Debug调试

2.9.1 打断点

• 断点位置

⽬标要调试的代码块的第⼀⾏代码即可，即⼀个断点即可。

• 打断点的⽅法

单击⽬标代码的⾏号右侧空⽩位置。

2.9.2 debug调试

打成功断点后，在⽂件内部任意位置 — 右键 – Debug’⽂件名’ — 即可调出Debug⼯具⾯板 – 单击StepOver/F8，即可按步执⾏代码。

2.9.3 debug输出面板分类

• Debugger
  • 显示变量和变量的细节
• Console
  • 输出内容

3.0 认识数据类型

目前入门阶段，我们主要接触如下三类数据类型

类型	描述	说明
string	字符串类型	用引号引起来的数据都是字符串
int	整型(有符号)	数据类型,存放整数 如 -1,10，0 等
float	浮点型(有符号)	数字类型，存放小数，如-3.14,6.65 等

3.1 type()语句

• 我们可以使用type()语句来得到数据的类型
• 语法：
  type(被查看类型的数据)

# 方式一:使用print直接输出类型信息
print(type("张三"));
print(type(666));
print(type(13.14));

# 方式二:使用变量存储type()语句的结果
string_type = type("张三");
int_type = type(666);
float_type = type(13.14);
print(string_type);
print(int_type);
print(float_type);

# 方式三:使用type()语句,查看变量中存储的数据类型的信息
name = "张三";
name_type = type(name);
print(name_type);

结果:
E:\pythonProject\venv\Scripts\python.exe E:\pythonProject\1.python基本语法\4.python数据类型.py 
<class 'str'> #str是string的缩写
<class 'int'>
<class 'float'>

变量有数据类型吗？

• 我们通过type(变量)可以输出类型，这是查看变量的类型还是数据的类型呢？
• 查看的是：变量存储的数据的类型，因为，变量无类型，但是它存储的数据有。

3.2 数据类型转换

数据类型之间，在特定的场景下，是可以相互转换的，如字符串转数字，数字转字符串等。
数据类型转换，将会是我们以后经常使用的功能。如：

• 从文件中读取的数字，默认是字符串，我们需要转换成为数字类型。
• 后续学习的input()语句，默认结果是字符串，若需要数字也需要转换。
• 将数字转换成字符串用以写出到外部系统，等等。

"""
常见转换语句
    int(x): 将x转换为一个整数
    float(x): 将x转换为一个个浮点数
    str(x): 将x转换为字符串
    str(x): 将x转换为字符串
"""

# 将数字类型转换成字符串
num_str = str(11);
print(type(num_str),num_str);

float_str = str(13.14);
print(type(float_str),float_str);

#将字符串转换为数字
num = int("111");
print(type(num),num);

num2 = float("13.14");
print(type(num2),num2);

#num3 = int("张三");
#print(type(num3),num3); #字符串转数据,必须确保字符串的内容是数字

# 整数转浮点数
float_num = float(11);
print(type(float_num),float_num);

# 浮点数转整数
int_num = int(13.14);
print(type(int_num),int_num); # 注意浮点数转整数,会丢失精度

结果:
<class 'str'> 11
<class 'str'> 13.14
<class 'int'> 111
<class 'float'> 13.14
<class 'float'> 11.0
<class 'int'> 13

• 算数运算符
• 赋值运算符
• 复合赋值运算符
• ⽐较运算符
• 逻辑运算符

3.3 算数运算符

3.4 赋值运算符

• 单个变量赋值

num = 1
print(num)

• 多个变量赋值

num1, float1, str1 = 10, 0.5, 'hello world'
print(num1)
print(float1)
print(str1)

• 多变量赋相同值

a = b = 10
print(a)
print(b)

3.5 复合赋值运算符

"""
算数(数学)运算符
    +  加  两个对象相加a+b输出结果为30
    -  减  得到负数或者是一个数减去另一个数a - b输出结果-10
    *  乘  两个数相乘或者返回一个呗重复若干次的字符串a * b输出结果200
    /  除  b/a输出结果为2
    //  取整数  返回商的整数部分9//2输出结果为4,9.0//2.0输出结果为4.0
    %  取余  返回除法的余数b%a输出结果0
    **  指数  a**b为10的20次方,输出结果为10000000000000000000000
"""

# 算数(数字)运算符
print("1 + 1 = ",1 + 1);
print("2 - 1 = ",2 - 1);
print("3 * 3 = ",3 * 3);
print("4 / 2 = ",4 / 2);
print("11 // 2 = ",11 // 2);
print("9 % 2 = ",9 % 2);
print("2 ** 2 = ",2 ** 2);

"""
赋值运算符
 =  赋值运算符  把=号右边的结果赋给左边的变量,如num = 1 + 2 * 3,结果num的值为7
"""

# 赋值运算符
num = 1 + 2 * 3;
print(num);

"""
复合赋值运算符
    +=  加法赋值运算符  c += a等效于c = c + a
    -=  减法赋值运算符  c -= a等效于c = c - a
    *=  乘法赋值运算符  c *= a等效于c = c * a
    /=  除法赋值运算符  c /= a等效于c = c / a
    %=  取模赋值运算符  c %= a等效于c = c % a
    **=  幂赋值运算符  c **= a等效于 c = c ** a
    //=  取整除赋值运算符  c //= a等效于c = c // a
"""

# 复合赋值运算符
num = 1;
num += 1; #num = num + 1;
print("num += 1:",num);
num -= 1;
print("num - = 1:",num);
num *= 4;
print("num *= 4:",num);
num /= 2;
print("num /= 2:",num);
num = 3;
num %= 2;
print("num %= 2:",num);
num **= 2;
print("num **= 2:",num);
num = 9;
num //= 2;
print("num //= 2:",num);

3.6 比较运算符

a = 7
b = 5
print(a == b) # False
print(a != b) # True
print(a < b) # False
print(a > b) # True
print(a <= b) # False
print(a >= b) # True

3.7 逻辑运算符

a = 1
b = 2
c = 3
print((a < b) and (b < c)) # True
print((a > b) and (b < c)) # False
print((a > b) or (b < c)) # True
print(not (a > b)) # True

3.8 字符串的三种定义方式

字符串在Python中有多种定形式:

• 单引号定义法: name = ‘张三’
• 双引号定义法: name = “张三”
• 三引号定义法" name =‘’‘张三’‘’

• 三引号定义法，和多行注释的写法一样，同样支持换行操作。
• 使用变量接收它，它就是字符串，不使用变量接收它，它就可以作为多行注释使用。

# 单引号定义法,使用单引号进行包围
name = '黑马程序员';
print(type(name));

##双引号定义法
name = "黑马程序员";
print(type(name));

#三引号定义法,写法和多行注释是一样的
name = """
    我是
    黑马
    程序员
"""
print(type(name));

3.9 字符串的引号嵌套

字符串的引号嵌套:
思考:如果我们想要定义字符串本身,是包含:单引号,双引号自身呢?该怎么写?

• 单引号定义法,可以内含双引号
• 双引号定义法,可以内含单引号
• 可以使用转义字符(),来将引号解除效用,变成普通字符串

# 在字符串内,包含双引号
name = '"黑马程序员"';
print(name);

# 在字符串内包含单引号
name = "'黑马程序员'";
print(name);

#使用转义字符 \ 接触引号的效用
name = "\"黑马程序员\"";
print(name);
name = '\'黑马程序员\'';
print(name);

4.0 字符串的拼接

字符串拼接:
如果我们有两个字符串(文本)字面量，可以将其拼接成一个字符串，通过 +号即可完成。
print(“学IT来黑马” + “月薪过万”)；
不过一般，单纯的2个字符串字面量进行拼接显得很呆，一般，字面量和变量或者变量和变了直接会使用拼接，如:
name = “黑马程序员”
print(“我的名字是:” + name +“,我可以教大家IT技能”);

# 字符串字面量之间的拼接
print("学IT来黑马" + "月薪过万");
# 字符串字面量和字符串变量之间的拼接
name = "黑马程序员";
address = "建材城东路0号院";
# tel = 110110; # 字符串只能和字符串拼接,不能和整数拼接
# print("我是" + name + ",我的地址是:" + address + "电话是: " # + tel );
print("我是" + name + ",我的地址是:" + address );

4.1 字符串的格式化

字符串格式化:

• 我们可以通过如下语法，完成字符串和变量的快速拼接.
  name = “黑马程序员”;
  message = “学IT就来%s” % name
  print(message)
• 其中的%s
  • %表示: 我要占位
  • s表示: 将变量变成字符串放入占位的地方

所以，综合起来的意思是：我先占个位置，等一会有个变量过来，我把它变成字符串放到占位的位置。
多个变量占位，变量要用括号括起来，并按照占位的顺序填入。
python中，其实支持非常多的数据类型占位。
最常用的是如下三类:

• %s 将内容转换成为字符串，放入占位位置，如果内容是数字，会转换成字符串
• %d 将内容转换成整数，放入占位位置
• %f 将内容转换成浮点型，放入占位位置

# 通过占位形式,完成拼接
name = "黑马程序员";
message = "学IT来: %s" % name;
print(message)

# 通过占位的形式,完成数字和字符串的拼接,此时的数字会被转换成为字符串
class_num = 57;
avg_salaary = 16789;
message = "Python大数据学科,北京%s期,毕业平均工资:%s" %(class_num,avg_salaary);

# 精确占位符
name = "传智播客";
setup_year = 2006;
stock_price = 19.99;
message = "%s,成立于:%d,我今天的股价是:%f" %(name,setup_year,stock_price);
print(message);

4.2 字符串格式化-精度控制

字符串格式化-数字精度控制
我们可以使用辅助符号"m.n"来控制数据的宽度和精度

• m：控制宽度，要求是数字(很少使用)，设置的宽度小于数字自身，不生效。
• .n：控制小数精度，要求是数字，会进行小数的四舍五入。

示例：

• %5d： 表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成:[空格][空格][空格]11，用三个空格补足宽度。
• %5.2f： 表示将宽度控制位5，将小数精度设置为2。
  小数点和小数部分也算入宽度计算。如：对11.345设置了%7.2f之后，结果是：[空格][空格]11.35。2个空格补足宽度，小数部分限制2为精度后，四舍五入为.35
• %.2f: 表示不限制宽度，只设置小数点精度为2，如：11.345设置%.2f后，结果是11.35。

num1 = 11;
num2 = 11.345;
print("数字11宽度限制5,结果是:%5d" % num1);
print("数字11宽度限制1,结果是:%1d" % num1);
print("数字11.345宽度限制7,小数精度2,结果是:%7.2f" % num2);
print("数字11.345不限制,小数精度2,结果是:%.2f" % num2)

4.3 字符串格式化-快速写法

字符串格式化-快速写法
目前通过%符号占位已经很方便了，还能进行精度控制。可是追求效率和优雅的Python，是否有更加优雅的方式解决问题呢?
那当然是有的。
通过语法： **f"内容[变量]"**的格式来快速格式化。该方式不理会类型，不做精度控制，适合对精度没有要求的时候快速使用。

name = "传智播客";
set_up_year = 2006;
stock_up_price = 19.19;
print(f"我是{name},我成立于:{set_up_year},我今天的股票价格是:{stock_up_price}");

4.4 表达式字符串格式化

对表达式进行字符串格式化：
表达式： 一条具有明确执行结果的代码语法。
如： 1 + 1,5 * 2,就是表达式，因为具有的结果，结果是一个数字。
又或者，常见的变量的定义：
name = “张三”，age = 11 + 11;
等号右侧的都是表达式，因为他们具有具体的结果，结果赋值给了等号左侧的变量。
在无需使用变量进行数据存储的时候，可以直接格式化表达式,简化代码哦。

# 演示对表达式进行字符串格式化
print("1 * 1的结果是:%d" %(1 * 1));
print(f"1 * 2的结果是: {1 * 2}");
print("字符串在Python中的类型是:%s" % type("字符串"));

4.5 字符串综合练习

- 股票计算小程序
"""
讲解字符串格式化的课后练习题
"""
# 定义变量
name = "传智播客" #公司名
stock_price = 19.99 #当前股价
stock_code = "003032" #股票结果
# 股票 价格 每日 增长 因子
stock_price_daily_growth_factor = 1.2 #股票每日增长系数,浮点数类型,比如1.2
growth_days = 7 #增长天数
finally_stock_price = stock_price * stock_price_daily_growth_factor ** growth_days;
print(f"公司:{name},股票代码:{stock_code},当前股价:{stock_price}");
print("每日增长系数:%f,经过%d天后的增长后,股价达到了:%.2f" %(stock_price_daily_growth_factor,growth_days,finally_stock_price))

结果:
公司:传智播客,股票代码:003032,当前股价:19.99
每日增长系数:1.200000,经过7天后的增长后,股价达到了:71.63

4.6 input语句

input语句(函数)：
在Python中，与之对应的还有一个input语句，用来获取键盘输入。

• 数据输出：print
• 数据输入：input

使用上也非常简单：

• 使用input()语句可以从键盘获取输入。
• 使用一个变量接收(存储) input语句获取的键盘输入数据即可。

备注：input接收的所有参数都是字符串，如果要进行转换，需要用到前面学习的数据类型转换。

# 演示Python的input语句,获取键盘的输入信息
# print("请告诉我你是谁?");
# name = input();
# print("我知道了,你是:%s" % name);

# input语句可以预设参数,与上面思想雷同
# name1 = input("请告诉我你是谁?");
# # print("我知道了,你是:%s" % name1);

num = input("请告诉我你的银行卡密码:");
# 因为input接收的输入都是字符串,如果要转换成整数,需要类型转换
num = int(num);
print("你的银行卡密码的类型是:",type(num))

第三章. Python判断语句

3.1 布尔类型

布尔类型：

• 进行判断结果，只有两种结果Ture或者False。True本质上是一个数字记作1，False记作0。

定义变量存储布尔类型数据：

• 变量名称 = 布尔类型字面量

布尔类型不仅仅可以自行定义，同时也可以通过计算得来。也就是使用比较运算符进行比较运算得到布尔类型的结果。

比较运算符

• == 判断内容是否相等，满足为True，不满足为False， 如a = 3，b = 3 则(a == b)为True。
• != 判断内容是否不相等，满足为True，不满足为False， 如a = 1，b = 3 则(a != b)为True。
• > 判断运算符左侧内容是否大于右侧，满足为True，不满足为False，如a = 7，b = 3，则(a > b)为True。
• < 判断运算符左侧内容是否小于右侧，满足为True，不满足为False， 如a = 3，b = 7,则(a > b)为True。
• >= 判断运算符左侧内容是否大于等于右侧，满足为True，不满足为False。 如a = 3，b = 3，则(a >= b)为True。
• >= 判断运算符左侧内容是否小于等于右侧，满足为True，不满足为False， 如a = 3，b = 3，则(a <= b)为True。

# 演示布尔类型的定义以及比较运算符的应用
# 定义变量存储布尔类型的数据
bool_1 = True;
bool_2 = False;
print(f"bool_1变量的内容是:{bool_1},类型是:{type(bool_1)}")
print(f"bool_1变量的内容是:{bool_2},类型是:{type(bool_2)}")

# 比较运算符的使用
# ==,!=,>,<,>=,<=
#演示进行内容的相等比较
num1 = 10;
num2 = 10;
print(f"10 == 10的结果是:{num1 == num2}");

num1 = 10;
num2 = 15;
print(f"10 != 15的结果是:{num1 != num2}");

name1 = "itcast";
name2 = "itheima";
print(f"itcast == itheima结果是:{name1 == name2}");

# 演示大于小于,大于等于,小于等于的比较运算
num1 = 10;
num2 = 5;
print(f"10 > 5结果是:{num1 > num2}");
print(f"10 < 5结果是:{num1 < num2}");

num1 = 10;
num2 = 10;
print(f"10 >= 10的结果是:{num1 >= num2}");
print(f"10 <= 10的结果是:{num1 <= num2}");

结果：
bool_1变量的内容是:True,类型是:<class 'bool'>
bool_1变量的内容是:False,类型是:<class 'bool'>
10 == 10的结果是:True
10 != 15的结果是:True
itcast == itheima结果是:False
10 > 5结果是:True
10 < 5结果是:False
10 >= 10的结果是:True
10 <= 10的结果是:True

3.2 if语句基本格式

• 基本语法

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

注意点:

• 判断语句的结果，必须是布尔类型True或者False。
• Ture会执行if内的代码语句。
• False则不会执行。
• 归属与if判断的代码语句块，需要在前方填充4个空格缩进。
• python通过缩进来判断代码块的归属关系。

# 演示Python判断语句,if语句的基本格式应用
age = 10;
if age > 18:
    print("我已经成年了!");
    print("即将步入大学生活");
print("时间过得真快呀!")

"""
演示练习题:成年人判断
"""
# 获取键盘输入
age = int(input("请输入您的年龄:"));
# 通过if判断是否是成年人
if age > 18:
    print("您已成年,游玩需要买票,10元.");
print("祝您游玩愉快!");

3.3 if else组合格式

• 基本语法

if else组合l判断
   else后,不需要判断条件
   和if的代码块一样，else的代码块同样需要4个空格作为缩进

# 演示Python中if else的组合判断语句
age = int(input("请输入您的年龄:"));
if age >= 18:
    print("您以成年,需要买票10元.");
else:
    print("您未成年,可以免费游玩.")

# 演示if else练习题: 我要买票吗
#定义键盘输入获取身高数据
height = int(input("请输入您的身高(cm):"))
# 通过if进行判断
if height > 120:
    print("您的身高超过120CM,需要买票10元.");
else:
    print("您的身高低于120CM,可以免费游玩");

print("祝您游玩愉快!")

3.4 if elif else 组合格式

• 基本语法

if else else语句
if 条件1:
    条件1满足应做的事情
elif 条件2:
    条件2满足应做的事情
elif 条件3:
    条件3满足应做的事情
else:
    所有条件都不满足的情况下应做的事情

# 演示if elif else 多条件来判断语句的使用
height = int(input("请您输入你的身高(CM):"));
vip_level = int(input("请您输入您的VIP等级(1-5):"));
day = int(input("请告诉我今天几号:"));
#通过if判断,可以使用多条件判断你的语法
# 第一个条件就是if
if height < 120:
    print("身高小于120CM,可以免费.");
elif vip_level > 3:
    print("vip级别大于3,可以免费.");
elif day == 1:
    print("今天是1号免费,可以免费")
else:
    print("不好意思,条件都不满足,需要买票10元.")

"""
练习案例：猜猜心里数字
1.定义一个变量，数字类型，内容随意
2.基于input语句输入猜想的数字，通过if和多次elif的组合，判断猜想数字是否和心中数字一致。
"""
# 定义一个变量数字
num = 5
# 通过键盘输入获取猜想的数字，通过多次if和elif的组合进行猜想比较
if int(input("请猜想一个数字:")) == num:
    print("恭喜第一此就猜对了")
elif int(input("猜错了，再猜一次：")) == num:
    print("猜对了")
elif int(input("猜错了，再猜一次吧：")) == num:
    print("恭喜，最后一次机会，您猜对了")
else:
    print("抱歉，你没有猜对")

3.5 判断语句的嵌套

• 基本语法

在生活中，许多逻辑的判断，是嵌套的，多层次的。
对于这种需求，我们可以自由的使用if elif else，完成特定需求的要求。
基本语法：
if 条件1:
    满足条件1 做的事情1
    满足条件1 做的事情2
    if 条件2:
        满足条件2 做的事情1
        满足条件2 做的事情2
如上图，第二个if，属于第一个if内，只有第一个if满足条件，才会执行第二个if。
嵌套的关键点在于：空格缩进。
通过空格缩进，来决定语句之间的：层次关系。

"""
演示判断语句的嵌套使用
"""
if int(input("你的升高是多少：")) > 120:
    print("身高超出限制，不可以免费")
    print("但是，如果vip级别大于3，可以免费")

    if int(input("你的vip级别是多少：")) > 3:
        print("恭喜你，vip级别达标，可以免费")
    else:
        print("对不起，你需要买票10元")
else:
    print("欢迎小朋友，免费游玩")

"""
自由组合嵌套，需求如下：
公司要发礼物，条件如下：
1.必须是大于等于18岁小于30岁的成年人
2.同时入职时间需满足大于两年，或者级别大于3才可以领取
"""
age = 20
year = 3
level = 3
if age > 18:
    print("你是成年人")
    if(age) < 30:
        print("你的年龄达标了")
        if year > 2:
            print("恭喜你，年龄和入职时间都达标，可以领取礼物")
        elif level > 3:
            print("恭喜你，年龄和级别达标，可以领取礼物")
        else:
            print("不好意思，尽管年龄达标了，但是入职时间和级别都不达标")
    else:
        print("不好意思，年龄太大了")
else:
    print("不好意思，小朋友不可用领取")

"""
案例需求：定义一个数字（1~·10随机产生)，通过3次判断猜出数字
案例要求：
1.数字随机产生
2.有3次机会猜测数字，通过3层嵌套判断实现
3.每次猜不中，会提示大了或者小了
"""
# 1.构建一个随机的数字变量
import random
num = random.randint(1,10)
guess_num = int(input("输入你要猜测的数字:"))

# 2.通过if判断语句进行数字的猜测
if guess_num == num:
    print("恭喜，第一次就猜中了")
else:
    if guess_num > num:
        print("你猜测的数字太大了")
    else:
        print("你猜测的数字小了")

    guess_num = int(input("再次输入你要猜测的数字:"))

    if guess_num == num:
        print("恭喜，第二次猜中了")
    else:
        if guess_num > num:
            print("你猜测的数字大了")
        else:
            print("你猜测的数字小了")

第四章. Python循环语句

4.1 while循环语句

• 语法

程序中的循环
while 条件：
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    .....
只要条件满足，会无限循环执行

"""
演示while循环的基本应用
注意点:
1.while的条件需要得到布尔类型，True表示继续循环，False表示结束循环
2.需要设置循环终止的条件，如i += 1配合i < 100,就能确保100次后停止，否则将无限循环
3.空格缩进和if判断一样，都需要设置
"""
i = 0
while i < 100:
    print("My liu，I love you")
    i += 1

"""
练习案例：求1-100的和
需求：通过while循环，计算从1累加到100的和
提示：
1.终止条件不能忘记，设置为确保while循环100次
2.确保累加的额数字，从1开始，到100结束
"""
sum = 0
i = 1
while i <= 100:
    sum += i
    i += 1
print(f"1-100累加的和是：{sum}")

"""
使用while循环完成猜数字案例
"""
# 获取范围在1-10的随机数字
import random
num = random.randint(1,10)
# 定义一个变量，记录总共猜测了多少次
count = 0;

#通过一个布尔类型的变量，做循环是否继续的标记
flag = True
while flag:
    guess_num = int(input("请输入你猜测的数字:"))
    count += 1
    if guess_num == num:
        print("猜中了")
        # 设置为False就是终止循环条件
        flag = False
    else:
        if guess_num > num:
            print("你猜的大了")
        else:
            print("你猜的小了")
print(f"你总共猜测了{count}次")

4.2 while循环的嵌套应用

• 基本语法:

基本语法：
while 条件1:
    条件1满足时，做的事情1
    条件1满足时，做的事情2
    条件1满足时，做的事情3
    ......
    while 条件2:
        条件2满足时，做的事情1
        条件2满足时，做的事情2
        条件2满足时，做的事情3
        .....
注意点:
1.同判断语句的嵌套一样，循环语句的嵌套，要注意控制缩进，基于空格缩进来决定层次关系。
2.注意条件的设置，避免出现无限循环。

"""
演示while循环的嵌套使用
"""
# 外层：表白100天的控制
# 内存：每天的表白都送10值玫瑰花的控制
i = 1
while i <= 100:
    print(f"今天是第{i}天，准备表白...")
    # 内存循环的控制变量
    j = 1
    while j <= 10:
        print(f"送给小美第{j}只玫瑰花")
        j += 1
    print("小美，我宣你")
    i += 1
print(f"坚持到第{i - 1}天，表白成功")

补充知识点1：print输出不换行
在print语句中，加上end=‘’既可以输出不换行。

"""
示例如下
"""
print("hello",end="")
print("world",end="")

补充知识点2：制表符\t
在字符串中，有一个特殊符号:\t,效果等同于键盘上的：tab键。
它可以让我们的多行字符串进行对齐。

print("Hello\tWorld")
print("zhang\tsan")

"""
while循环嵌套使用的综合案例
通过while循环打印九九乘法表
"""
# 定义外层循环的控制变量
i = 1
while i <= 9:
    # 定义内存循环的控制变量
    j = 1
    while j <= i:
        #内存循环的print语句，不能换行，通过\t制表符进行对齐
        print(f"{j} * {i} = {j * i}\t",end="")
        j += 1
    i += 1;
    print() #print()空内容，就是输出一个换行

4.3 for循环语句

除了while循环语句外，Python同样提供了for循环语句。
两者能完成的功能基本差不多，但仍有一些区别：

• while循环的循环条件是自定义的，自行控制循环条件。
• for循环式一种轮询机制，是对一批内容进行逐个处理。

程序中的for循环语法：
for 临时变量 in 待处理数据集:
    循环满足条件时执行的代码

注意点：

• 同while循环不同，for循环式无法定义循环条件的。
• 只能从被处理的数据集中，依次取出内容进行处理。

所以，理论上讲，Python的for循环无法构建无限循环（被处理的数据集不可能无限大）

"""
演示for循环的基本语法
"""
name = "chentf"
for x in  name:
    # 将name的内容，挨个取出赋值给x临时变量
    # 就可以在循环体内对x进行处理
    print(x)

"""
练习案例：数一数有几个a。
定义字符串变量name，统计有多少个英文字母：”a"
通过for循环，遍历次字符串，统计出有多少个英文字母：“a"
提示：
1.计数可以在循环外定义一个整数类型变量用来做累加计数
2.判断是否为字母“a",可以通过if语句结合比较运算符来完成
"""
name = "my name is zhangsan，hello Python"
#定义一个变量，用来统计有多少a
count = 0
# for循环 临时变量in 被统计的数据:
for x in name:
    if x == "a":
        count += 1
print(f"被统计的字符串有{count}个a")

for临时变量in待处理数据集：
    循环满足条件时执行的代码

回看for循环的语法，我们会发现，将从数据集（序列）中取出的数据赋值给：临时变量
为什么是临时的呢？

• 临时变量，在编程规范上，作用范围（作用域），只限定在for循环内部

如果在for循环外部访问临时变量：

• 实际上是可以访问到的
• 在编程规范上，是不允许、不建议这么做的

演示Python for循环临时变量的作用域
"""
i = 0
for i in range(5):
    print(i)

print(i)

4.4 for循环嵌套使用

程序中的嵌套for循环语法：
for临时变量in待处理数据集（序列）:
    循环满足条件应做的事情1
    循环满足条件应做的事情2
    循环满足条件应做的事情N
    for临时变量1n待处理数据集（序列）:
        循环满足条件应做的事情1
        循环满足条件应做的事情2
        循环满足条件应做的事情N

"""
演示嵌套应用for循环
"""
# 坚持表白100天，每天送10朵花
i = 0
for i in range(1,101):
    print(f"今天是向小美表白的第{i}天，加油坚持")

    # 写内层的循环
    for j in range(1,11):
        print(f"给小美送的第{j}朵玫瑰花")

    print("小美我宣你")
print(f"第{i}，表白成功")

"""
改造成while循环
"""
i = 1
while i <= 100:
    print(f"今天是向小美表白的第{i}天，坚持")
    for j in range(1,11):
        print(f"送给小美的第{j}朵玫瑰花")
    print(f"小美，我宣你(第{i}天的表白结束)")
    i += 1
print(f"表白第{i - 1}天，表白成功")

"""
练习案例：九九乘法表
"""

# 通过外层循环控制行数
for i in range(1,10):
    # 通过内层循环控制每一行的数据
    for j in range(1,i + 1):
        # 在内层循环中输出每一行的内容
        print(f"{j} * {i} = {j * i}\t",end="")

    # 外层循环可以通过print输出一个回车符
    print()

4.5 range()语法

for循环语法：
for 临时变量in 待处理数据集:
    循环满足条件是执行的代码
语法中：待处理的数据集，严格来说，称之为:序列类型
序列类型指，其内容可以一个个依次取出的一种类型,包括:
	- 字符串
    - 列表
    - 元组

range语法1：
range(num)
获取一个从0开始，到num结束的数字序列（不含num本身）
如range(5)取得的数据是:[0,1,2,3,4]

range语法2：
range(num1,num2)
获取一个从num1开始，到num2结束的数字序列（不含num2本身）
如range(5,10)取得的数据是:[5,6,7,8,9]

range语法3：
range(num1,num2,step)
获取一个从num1开始，到num2结束的数字序列（不含num2本身）
数字之间的步长，已step为准（step默认为1）
如range(5,10,2)取得的数据是:[5,7,9]

"""
演示rangee()语句的基本使用
"""

# range语法1 range(num)
for x in range(10):
    print(x)

# range语法2 rang(num1,num2)
for x in range(5,10):
    # 从5开始，到10结束（不包含10本身）的一个数字序列，数字之间间隔是1
    print(x)

# range语法3 range(num1,num2,step)
for x in range(5,10,2):
    # 从5开始，到10结束（不包含10本身）的一个数字序列，数字之间间隔2
    print(x)

4.6 break,continue关键字

思考：无论是while循环或是for循环，都是重复性的执行特定操作。
在这个重复的过程中，会出现一些其它情况让我们不得不：

• 暂时跳过某次循环，直接进行下一次
• 提前退出循环，不在继续

continue关键字用于：中断本次循环，直接进入下一循环
continue可以用于：for循环和while循环，效果一致
for i in range(1,100):
    语句1
    continue
    语句2
左侧代码：
    - 在循环内，遇到continue就结束当次循环，进行下一次
    - 所以，语句2是不会执行的。
应用场景：
    - 在循环中，因某些原因，临时结束本次循环。

# 演示循环中断语句continue
for i in range(1,6):
    print("语句1")
    continue
    print("语句2")

# 演示continue的嵌套使用
for i in range(1,6):
    print("语句1")
    for j in range(1,6):
        print("语句2")
        continue
        print("语句3")
    print("语句4")

break关键字用于：`直接结束循环`
break可以用于：`for循环和while循环，效果一致`
for i in range(1,100):
    语句1
    break
    语句2
语句3
左侧代码：
    - 在循环内，遇到break就结束循环了
    - 所以，执行了语句1后，直接执行语句3了

# 演示循环中断语句break
for i in(1,101):
    print("语句1")
    break
    print("语句2")
print("语句3")

# 演示break的嵌套使用
for i in range(1,6):
    print("语句1")
    for j in range(1,6):
        print("语句2")
        break
        print("语句3")
    print("语句4")

注意事项：

• continue和break，在for和while循环中作用一致。
• 在嵌套循环中，只能作用在所在的循环上，无法对上层循环起作用。

• 综合案例

"""
练习案例：发工资
某公司，账户余额有1W元，给20名员工发工资。
- 员工编号从1到20，从编号1开始，依次领取工资，每人可领取1000元
- 领工资时，财务判断员工的绩效分（1-10)（随机生成），如果低于5，不发工资，换下一位
- 如果工资发完了，结束发工资。
提示：
- 使用循环对员工依次发放工资
- continue用于跳过员工，break直接结束发工资
- 随机数可以用：
    import random
    num random.randint(1,10)
"""

# 演示循环综合案例：发工资

#定义账户余额变量
money = 10000
# for循环对员工发工资
for i in range(1,21):
    import random
    score = random.randint(1,10)

    if score < 5:
        print(f"员工{i}绩效分{score}，不满足，补发工资，下一位")
        # continue
        continue

    # 要判断余额足不足
    if money >= 1000:
        money -= 1000
        print(f"员工{i}，满足条件发工资1000，公司账上余额：{money}")
    else:
        print(f"余额不足，当前余额：{money}元，不足以发工资，不发了，下个月再来")
        # break结束发放
        break

第五章 Python函数

5.1 函数的基本语法

函数：是组织好的，可重复使用的，用来实现特定功能的代码段。
为什么随时都可以使用len()统计长度？
因为，len()是Python内置的函数：

• 是提前写好的
• 可以重复使用
• 实现统计长度这一特定功能的代码段

为什么要学习、使用函数呢？
为了得到一个针对特定需求、可供重复利用的代码段，提高程序的复用性，减少重复性代码，提高开发效率。

"""
演示：快速体验函数的开发及应用
"""
# 需求，统计字符串长度，不使用内置函数len()
str1 = "zhangsan"
str2 = "lisi"
str3 = "wangwu"

# 定义一个计数的变量
count = 0
for i in str1:
    count += 1
print(f"字符串{str1}的长度是：{count}")

count = 0
for i in str2:
    count += 1
print(f"字符串{str2}的长度是：{count}")

count = 0
for i in str3:
    count += 1
print(f"字符串{str3}的长度是：{count}")

函数的定义：
def 函数名（传入参数）
    函数体
    return返回值

函数的调用：
函数名(参数)

注意事项：
1.参数如不需要，可以省略
2.返回值如不需要，可以省略
3.函数必须先定义后使

"""
演示函数的定义语法
"""
# 定义一个函数，输出相关信息
def say_hello():
    print("hello,我是chentf，欢迎学习Python")

# 调用函数，让定义的函数开始工作
say_hello()

"""
练习案例：自动查核酸
定义一个函数，函数名任意，要求调用函数后可以输出如下欢迎语：
    欢迎来到Pthon学习基地！
    请出示您的健康码以及72小时核酸证明！
"""
# 定义函数
def check():
    # 编写函数体输出信息
    print(" 欢迎来到Pthon学习基地！\n请出示您的健康码以及72小时核酸证明！")

# 调用函数
check();

5.2 函数传入参数

函数的传入参数
传入参数的功能是：在函数进行计算的时候，接受外部（调用时）提供的数据
基于函数的定义语法：
def 函数名（传入参数）
    函数体
    return返回值
注意事项：
    - 函数定义中的参数，称之为形式参数
    - 函数调用中的参数，称之为实际参数
    - 函数的参数数量不限，使用逗号分隔开
    - 传入参数的时候，要和形式参数一一对应，逗号隔开

"""
演示函数使用参数
语法解析:
函数定义中，提供的x和y,称之为：形式参数（形参），表示函数声明将要使用2个参数
    - 参数之间使用逗号进行分隔
函数调用中，提供的5和6，称之为：实际参数（实参），表示函数执行时真正使用的参数值
    - 传入的时候，按照顺序传入数据，使用逗号分隔
"""
# 定义2数相加的函数，通过参数接收被计算的2个数字
def add(x,y):
    result = x + y
    print(f"{x} + {y}的计算结果是：{result}")

# 调用函数，传入被计算的2个参数
add(5,6)

"""
演示函数的参数练习案例：升级自动查核酸
"""

# 定义函数，接收1个形式参数，数字类型，表示体温
def check(num):
    # 在函数体内进行判断体温
    print("欢迎来到Pthon学习基地！\n请出示您的健康码以及72小时核酸证明，并配合测量体温！")
    if num <= 37.5:
        print(f"体温测量中，您的体温是：{num}度，体温正常请进！")
    else:
        print(f"体温测量中，您的体温是：{num}度，需要隔离！")

# 调用函数，传入实际参数
check(37.6)

5.3 函数的返回值

None类型的应用场景
None作为一个特殊的字面量，用于表示：空、无意义，其有非常多的应用场景。
- 用在函数无返回值上
- 用在f判断上
    -- 在if判断中，None等同于False
    -- 一般用于在函数中主动返回None,配合if判断做相关处理
- 用于声明无内容的变量上
    -- 定义变量，但暂时不需要变量有具体值，可以用None来代替
    #暂不赋予变量具体值
    name = None

# None用于if判断
def check_age(age):
    if age > 18:
        return "SUCCESS"
    else:
        return None

result = check_age(17)
if not result:
    # 进入if表示result是None值，也就是false
    print("未成年人，不可以进入网吧")

# None用于声明无初始内容的变量
name = None

5.4 函数的说明文档

函数是纯代码语言，想要理解其含义，就需要一行行的去阅读理解代码，效率比较低。
我们可以给函数添加说明文档，辅助理解函数的作用。
通过多行注释的形式，对函数进行说明解释
    - 内容应写在函数体之前

"""
演示对函数进行文档说明
"""
# 定义函数，进行文档说明
def add(a, b):
    """
    add函数可以接受2个参数，进行2数相加的功能
    :param a: 形参a表示相加的其中一个数字
    :param b: 形参b表示相加的其中另一个数字
    :return: 返回值是2数相加的结果
    """
    result = a + b
    print(f"2数相加的结果是：{result}")

add(12, 12)

5.5 函数的嵌套使用

什么是函数的嵌套：
所谓函数嵌套调用指的是一个函数里面又调用了另外一个函数

"""
演示函数嵌套调用
函数A中执行到调用函数B的语句，会将函数B全部执行完成后，继续执行函数A的剩余内容
"""
# 定义函数
def func_b():
    print("---2---")

# 定义函数
def func_a():
    print("---1---")

    #   嵌套调用函数func_b
    func_b()
    print("---3---")

func_a()

5.6 函数变量的作用域

变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）。
主要分为两类：局部变量和全局变量。
所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效。
局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则局部变量销毁
所谓全局变量，指的是在函数体内外都能生效的变量
思考：如果有一个数据，在函数A和函数B中都要使用，该怎么办？
答：将这个数据存储在一个全局变量里面

"""
演示在函数使用的时候，定义的变量作用域
"""
# 演示局部变量
def test_a():
    num = 100
    print(num)
test_a()

# 演示全局变量
num = 200
def test_x():
    print(f"test_x:{num}")

def test_y():
    print(f"test_y:{num}")

test_x()
test_y()
print(num)

"""
global关键字:
使用global关键字可以在函数内部声明变量为全局变量
"""

# 在函数内修改全局变量
num = 200
def test_1():
    print(f"test_1:{num}")

def test_2():
    print(f"test_2:{num}")

test_1()
test_2()
print(num)

# global关键字，在函数内声明变量为全局变量
def test_3():
    global num # 设置内部定义的变量为全局变量
    num = 500
    print(f"test_3:{num}")
test_1()
test_2()
test_3()
print(num)

5.7 综合案例

"""
演示函数综合案例开发
综合案例：自动取款机ATM
,定义一个全局变量：money,用来记录银行卡余额（默认5000000）
定义一个全局变量：name,用来记录客户姓名（启动程序时输入）
定义如下的函数：
    - 查询余额函数
    - 存款函数
    - 取款函数
    - 主菜单函数
要求：
    - 程序启动后要求输入客户姓名
    - 查询余额、存款、取款后都会返回主菜单
    - 存款、取款后，都应显示一下当前余额
    - 客户选择退出或输入错误，程序会退出，否则程序会一直运行
"""
# 定义全局变量money，name
money = 5000000
name = None
# 要求客户输入姓名
name = input("请输入您的姓名:")
# 定义查询函数
def query(show_header):
    if show_header:
        print("------查询余额-------")
    print(f"{name},您好，您的余额剩余：{money}元")

#定义存款函数
def saving(num):
    global money # money在函数内部定义为全局变量
    money += num
    print("--------存款---------")
    print(f"{name},您好，您存款{num}元成功。")

    # 调用query函数查询余额
    query(False)

# 定义取款函数
def get_money(num):
    global money
    money -= num
    print("---------取款----------")
    print(f"{name}，您好，您取款{num}元成功。")

    # 调用query函数查询余额
    query(False)

# 定义主菜单函数
def main():
    print("------主菜单-------")
    print(f"{name},您好，欢迎来到自动取款机ATM，请选择操作：")
    print("查询余额\t[输入1]")
    print("存款\t\t[输入2]")
    print("取款\t\t[输入3]")
    print("退出\t\t[输入4]")
    return input("请输入您的选择：")

# 设置无线循环，确保程序不退出
while True:
    keyboard_input = main()
    if keyboard_input == "1":
        query(True)
        continue # 通过continue继续下一次循环，一进来就回到了主菜单
    elif keyboard_input == "2":
        num = int(input("您想要存入多少钱?请输入:"))
        saving(num)
    elif keyboard_input == "3":
        num = int(input("您想要取出多少钱?请输入:"))
        get_money(num)
        continue
    else:
        print("程序退出！")
        break  #通过break退出循环

第六章 Python数据容器

6.1 列表的定义

Python中的数据容器：
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素A，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
数据容器根据特点的不同，如：
    - 是否支持重复元素
    - 是否可以修改
    - 是否有序，等
分为5类，分别是：列表(list)、元组(tuple)、字符串(str)、集合（set)、字典(dict)

列表的定义
基本语法：
#字面量
[元素1，元素2，元素3，元素4，..]
#定义变量
变量名称=[元素1，元素2，元素3，元素4，...]
#定义空列表
变量名称=[]
变量名称=1ist()
列表内的每一个数据，称之为元素
    - 以[]作为标识
    - 列表内每一个元素之间用，逗号隔开
注意：列表可以一次存储多个数据，可以为不同的数据类型，支持嵌套。

"""
演示数据容器之list列表
语法：[元素1，元素2，元素3，元素4，..]
"""
# 定义一个列表list
my_list = ["zhangsan","lisi","wangwu"]
print(my_list)
print(type(my_list))

# 存储不同数据类型的元素
my_list = ["zhangsan",666,True]
print(my_list)
print(type(my_list))

# 定义一个嵌套的列表
my_list = [[1,2,3],[4,5,6]]
print(my_list)
print(type(my_list))

"""
列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增
我们只需要按照下标索引，即可取得对应位置的元素。
语法：列表[下标索引]
注意：下标索引的取值范围，超出范围无法取出元素，并且会报错
"""

# 通过下标索引取出对应位置的数据
my_list = ["zhangsan","lisi","wangwu"]
# 列表[下标索引]，从前向后从0开始，每次+1，从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])

"""
可以反向索引，也就是从后向前：从-1开始，依次递减(-1、-2、-3....)
"""
# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

# 取出嵌套列表的元素
my_list = [[1,2,3],[4,5,6]]
print(my_list[1][1])

6.2 列表的常用操作

"""
列表除了可以：
    - 定义
    - 使用下标索引获取值
以外，列表也提供了一系列功能：
    - 插入元素
    - 删除元素
    - 清空列表
    - 修改元素
    - 统计元素个数
等等功能，这些功能我们都称之为：列表的方法
"""

"""
列表的查询功能（方法)
- 查找某元素的下标
功能：查找指定元素在列表的下标，如果找不到，报错ValueError
语法：列表.index(元素)
index就是列表对象（变量）内置的方法（函数）

- 插入元素：
语法：列表.insert(下标,元素)，在指定的下标位置，插入指定的元素.

- 追加元素方式1：
语法：列表.append(元素)，将指定元素，追加到列表的尾部.

- 追加元素方式2：
语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部.

- 删除元素：
语法1：del列表[下标]
语法2：列表.pop(下标)

- 删除某元素在列表中的第一个匹配项
语法：列表.remove(元素)

- 清空列表内容
语法：列表.clear()

- 统计某元素在列表内的数量
语法：列表.count(元素)

- 统计列表内，有多少元素
语法：len(列表)
可以得到一个int数字，表示列表内的元素数量
"""

"""
演示数据容器之list列表的常用操作
"""
my_list = ["zhangsan","lisi","wangwu"]

# 1.1 查找某元素在列表内的下标索引
index = my_list.index("zhangsan")
print(f"zhangsan在列表中的下标索引值是：{index}")
# 1.2 如果被查找的元素不存在，会报错
# index = my_list.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")

# 2. 修改特定下标的索引值
my_list[0] = "sunwukong"
print(f"列表被修改元素值后，结果是：{my_list}")

# 3.在指定下标位置插入新元素
my_list.insert(1,"tangseng")
print(f"列表插入元素后，结果是：{my_list}")

# 4.在列表的尾部追加单个元素
my_list.append("shaheshang")
print(f"列表在追加了元素后，结果是：{my_list}")

# 5.在列表的尾部追加一批新元素
my_list2 = [1,2,3]
my_list.extend(my_list2)
print(f"列表在追加了一个新的列表后，结果是：{my_list}")

# 6.删除指定下标索引的元素（2中方式）
# 6.1 方式一：del 列表[下标]
del my_list[2]
print(f"列表删除元素后结果是：{my_list}")

# 6.2 方式二：列表.pop[下标]
my_list = ["beijing","shanghai","guangzhou"]
element = my_list.pop(2)
print(f"通过pop方法取出元素后列表内容：{my_list},取出的元素是：{element}")

# 7.删除某元素在列表中的第一个匹配项
my_list = ["beijing","shanghai","guangzhou","shenzheng","hangzhou","beijing","hangzhou"]
my_list.remove("hangzhou")
print(f"通过remove方法移除元素后，列表的结果是：{my_list}")

# 8.清空列表
my_list.clear()
print(f"列表被清空了，结果是：{my_list}")

# 9.统计列表内某元素的数量
my_list = ["beijing","shanghai","guangzhou","shenzheng","hangzhou","beijing","hangzhou"]
count = my_list.count("beijing")
print(f"列表中beijing的数量是：{count}")

# 10.统计列表中全部元素数量
my_list = ["beijing","shanghai","guangzhou","shenzheng","hangzhou","beijing","hangzhou"]
count = len(my_list)
print(f"列表的元素数量总共有：{count}个")

经过上述对列表的学习，可以总结出列表有如下特点：

• 可以容纳多个元素（上限为2*63-1、9223372036854775807个）
• 可以容纳怀同类型的元素（混装）
• 数据是有序存储的（有下标序号）
• 允许重复数据存在
• 可以修改（增加或删除元素等)

"""
练习案例：常用功能练习
有一个列表，内容是：[21,25,21,23,22,20]，记录的是一批学生的年龄
请通过列表的功能（方法），对其进行
    1.定义这个列表，并用变量接收它
    2.追加一个数字31，到列表的尾部
    3.追加一个新列表[29,33,30]，到列表的尾部
    4.取出第一个元素（应是：21)
    5.取出最后一个元素（应是：30)
    6.查找元素31，在列表中的下标位置
"""
# 1.定义这个列表，并用变量接收它
mylist = [21,25,21,23,22,20]

# 2.追加一个数字31，到列表的尾部
mylist.append(31)

# 3.追加一个新列表[29,33,30]，到列表的尾部
mylist.extend([29,33,30])

# 4.取出第一个元素（应是：21)
num1 = mylist[0]
print(f"从列表中取出第一个元素，应该是21，实际上是：{num1}")

# 5.取出最后一个元素（应是：30)
num2 = mylist[-1]
print(f"从列表中取出最后一个元素，应该是30，实际上是：{num2}")

# 6.查找元素31，在列表中的下标位置
index = mylist.index(31)
print(f"元素31在列表的下标位置：{index}")
print(f"最后列表的内容是：{mylist}")

6.3 列表的循环

"""
列表的遍历-while循环
既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。
将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。
如何遍历列表的元素呢？
    - 可以使用前面学过的while循环
如何在循环中取出列表的元素呢？
    - 使用列表[下标]的方式取出
循环条件如何控制？
    - 定义一个变量表示下标，从0开始
    - 循环条件为下标值<列表的元素数量
"""

"""
演示对list列表的循环：使用while和for循环2中方式
"""
def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    my_list = ["zhangsan","lisi","wangwu"]
    # 循环控制变量通过下标索引来控制，默认0
    # 每一次循环将下标索引变量+1
    # 循环条件：下标索引变量 < 列表的元素数据

    # 定义一个变量用来标记列表的下标
    index = 0 # 初始化值为0
    while index < len(my_list):
        # 通过index变量取出对应下标的元素
        element = my_list[index]
        print(f"列表的元素：{element}")
        # 关键点，将循环变量index每一次循环+1
        index += 1

list_while_func()

"""
列表的遍历-for循环
除了while循环外，Python中还有另外一种循环形式：for循环。
对比while,for循环更加适合对列表等数据容器进行遍历。
语法：
for 临时变量 in 数据容器
    对临时变量进行处理
表示，从容器内，依次取出元素并赋值到临时变量上。
在每一次的循环中，我们可以对临时变量（元素）进行处理。
"""

def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return: None
    """
    my_list = ["zhangsan","lisi","wangwu"]
    # for 临时变量 in 数据容器:
    for element in my_list:
        print(f"列表的元素有：{element}")

list_for_func()

"""
while循环和for循环，都是循环语句，但细节不同：
- 在循环控制上：
    -- while循环可以自定循环条件，并自行控制
    -- for循环不可以自定循环条件，只可以一个个从容器内取出数据
- 在无限循环上：
    -- while循环可以通过条件控制做到无限循环
    -- for循环理论上不可以，因为被遍历的容器容量不是无限的
- 在使用场景上：
    -- while循环适用于任何想要循环的场景
    -- for循环适用于，遍历数据容器的场景或简单的固定次数循环场景
"""

6.4 元组

思考：列表是可以修改的。
如果想要传递的信息，不被篡改，列表就不合适了。
元组同列表一样，都是可以封装多个、不同类型的元素在内。
但最大的不同点在于：元组一旦定义完成，就不可修改
所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了.
元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
#定义元组字面量
(元素，元素，·，元素)
#定义元组变量
变量名称=（元素，元素，...，元素）
#定义空元组
变量名称=() #方式1
变量名称=tuple() #方式2
注意事项：
- 不可以修改元组的内容，否则会报错
- 可以修改元组内的list的内容（修改元素，增加，删除，反转等）

"""
演示tuple元组的定义和操作
"""
# 定义元组
t1 = (1,"hello",True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)}，内容是：{t1}")
print(f"t2的类型是：{type(t2)}，内容是：{t2}")
print(f"t3的类型是：{type(t3)}，内容是：{t3}")

# 定义单个元组的元素
t4 = ("hello",) # 备注，单个元素，必须加,
print(f"t4的类型是：{type(t4)}，t4的内容是：{t4}")

# 元组的嵌套
t5 = ((1,2,3),(4,5,6))
print(f"t5的类型是：{type(t5)}，t5内容是：{t5}")

# 下标索引去取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")

# 元组的操作：index查找方法
t6 = ("zhangsan","lisi","wangwu")
index = t6.index("lisi")
print(f"在元组t6中查找lisi的下标是：{index}")

# 元组的操作：count统计方法
t7 = ("zhangsan","lisi","wangwu","zhangsan")
num = t7.count("zhangsan")
print(f"在元组t7中统计zhangsan的数量有：{num}个")

# 元组的操作：len函数统计元组元素数量
t8 = ("zhangsan","lisi","wangwu","zhangsan")
num = len(t8)
print(f"t8元组中的元素有：{num}个")

# 元组的遍历：while
index = 0
while index < len(t8):
    print(f"元组的元素有：{t8[index]}")
    #关键点
    index += 1

# 元组的遍历：for
for element in t8:
    print(f"元组的元素有：{element}")

# 修改元组内容
# t8[0] = "tangseng"

# 定义一个元组
t9 = (1,2,["zhangsan","lisi"])
print(f"t9的内容是：{t9}")
t9[2][0] = "sunwukong"
t9[2][1] = "zhubajie"
print(f"t9的内容是：{t9}")

"""

经过上述对元组的学习，可以总结出列表有如下特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是有序存储的（下标索引)
• 允许重复数据存在
• 不可以修改（增加或删除元素等)
• 支持fo循环

多数特性和list一致，不同点在于不可修改的特性。

6.5 字符串

尽管字符串看起来并不像：列表、元组那样，一看就是存放了许多数据的容器。
但不可否认的是，字符串同样也是数据容器的一员。
字符串是字符的容器，一个字符串可以存放任意数量的字符。
如，字符串：“itheima”

"""
演示数据容器，学习字符串的相关操作
- 字符串的下标（索引)
和其它容器如：列表、元组一样，字符串也可以通过下标进行访问
    - 从前向后，下标从0开始
    - 从后向前，下标从-1开始
同元组一样，字符串是一个：无法修改的数据容器。
所以：
    - 修改指定下标的字符(如：字符串[0]=“a”)
    - 移除特定下标的字符(如：del字符串[o]、字符串.remove()、字符串.pop()等)
    - 追加字符等(如：字符串.append())
均无法完成，如果必须要做，只能得到一个新的字符串，而原字符串是无法修改的

- 字符串的替换
语法：字符串.replace(字符串1，字符串2)
功能：将字符串内的全部：字符串1，替换为字符串2
注意：不是修改字符串本身，而是得到了一个新字符串哦

- 字符串的分割
语法：字符串.split(分隔符字符串)
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象

- 字符串的规整操作（去前后空格）
语法：字符串strip()

-字符串的规整操作（去前后指定字符串）
语法：字符串.strip(字符串) 
注意，传入的是12，其实就是：1和2都会移除，是安装单个字符。
"""

my_str = "my name is zhangsan"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素。值是：{value},取下标为-16的元素。值是：{value2}")

# index方法
value = my_str.index("is")
print(f"在字符串{my_str}中查找is，其起始下标是：{value}")

# replace方法
new_my_str = my_str.replace("zhangsan","lisi")
print(f"将字符串{my_str}进行替换后得到:{new_my_str}")

# split方法
my_str = "welcome to china"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list},类型是：{type(my_str_list)}")

# strip
my_str = "  welcome to china  "
new_my_str = my_str.strip() # 不传入参数，去除收尾空格
print(f"字符串{my_str}被strip后，结果：{new_my_str}")

my_str = "12welcome to china211"
new_my_str = my_str.strip("12")
print(f"字符串{my_str}被strip('12')后，结果是：{new_my_str}")

# 统计字符串中某字符串的出现次数
my_str = "itheima and itcast"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是：{count}")

# 统计字符串的长度
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")

"""
作为数据容器，字符串有如下特点：
    - 只可以存储字符串
    - 长度任意（取决于内存大小)
    - 支持下标索引
    - 允许重复字符串存在
    - 不可以修改（增加或删除元素等）
    - 支持for循环
"""

"""
练习案例：分割字符串
给定一个字符串："litheima itcast boxuequ
    - 统计字符串内有多少个"t字符
    - 将字符串内的空格，全部替换为字符："|”
    - 并按照"|"进行字符串分割，得到列表
"""
"""
字符串课后练习演示
"""
my_str = "litheima itcast boxuequ"
# 统计字符串内有多少个‘it’字符
num = my_str.count("it")
print(f"字符串{my_str}中有{num}个字符")

# 将字符串内的空格，全部替换成为字符：“|”
new_my_str = my_str.replace(" ","|")
print(f"字符串{my_str}被替换空格后，结果是：{new_my_str}")

# 并按照“|”进行字符串分割，得到列表
my_str_list = new_my_str.split("|")
print(f"字符串{new_my_str}按照'|'分割后结果是：{my_str_list}")

6.6 序列

"""
序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。

序列的常用操作-切片
序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列
语法：序列[起始下标:结束下标:步长]
- 表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
    -- 起始下标表示从何处开始，可以留空，留空视作从头开始
    -- 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
- 步长表示，依次取元素的间隔
    -- 步长1表示，一个个取元素
    -- 步长2表示，每次跳过1个元素取
    -- 步长N表示，每次跳过N-1个元素取
    -- 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记)
注意：此操作不会影响序列本身，而是会得到一个新的序列（列表，元组，字符串）
- 序列[起始:结束:步长]
    -- 起始可以省略，省略从头开始
    -- 结束可以省略，省略到尾结束
    -- 步长可以省略，省略步长为1（可以为负数，表示倒序执行）
"""

"""
演示对序列进行切片操作
"""
# 对list进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5,6]
result1 = my_list[1:4] # 步长默认为1，所以可以省略不写
print(f"结果1：{result1}") # 结果1：[1, 2, 3]

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:] # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2：{result2}") # 结果2：(0, 1, 2, 3, 4, 5, 6)

# 对str进行切片，从头开始，到最后结束，步长1
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}") # 结果3：0246

# 对str进行切片，从头开始，到最后结束，步长1
my_str = "01234567"
result4 = my_str[::-1] # 等同于将序列反转了
print(f"结果4：{result4}") # 结果4：76543210

# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0,1,2,3,4,5,6,7]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}") # 结果5：[3, 2]

# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple= (0,1,2,3,4,5,6,7)
result6 = my_tuple[::-2]
print(f"结果6：{result6}") # 结果6：(7, 5, 3, 1)

"""
练习案例：序列的切片实践
有字符串："万过薪月，员序程马黑来，nohtyP学”
    - 请使用学过的任何方式，得到"黑马程序员"
可用方式参考：
    - 倒序字符串，切片取出或切片取出，然后倒序
    - split:分隔"，"replace替换"来"为空，倒序字符串
"""
my_str = "万过薪月，员序程马黑来，nohtyP学"
# 倒序字符串，切片取出
result1 = my_str[::-1][9:14]
print(f"方式1结果：{result1}")
#切片取出，然后倒序
result2 = my_str[5:10][::-1]
print(f"方式2结果：{result2}")

# split分隔"."，replace替换“来”为空，倒序字符串
result3 = my_str.split("，")[1].replace("来","")[::-1]
print(f"方式3结果：{result3}")

6.7 set(集合)

"""
我们目前接触到了列表、元组、字符串三个数据容器了。基本满足大多数的使用场景。
为何又需要学习新的集合类型呢？
通过特性来分析：
    - 列表可修改、支持重复元素且有序
    - 元组、字符串不可修改、支持重复元素且有序
有没有看出一些局限？
局限就在于：它们都支持重复元素。
如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。
而集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序

集合的定义，基本语法：
# 定义集合字面量
{元素，元素，....，元素}
# 定义集合变量
变量名称={元素，元素，，元素}
# 定义空集合
变量名称=set()

和列表、元组、字符串等定义基本相同：
    - 列表使用：[]
    - 元组使用：()
    - 字符串使用：""
    - 集合使用：{}
"""

"""
演示数据容器集合的使用
- 集合的常用操作-修改
首先，因为集合是无序的，所以集合不支持：下标索引访问
但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。

- 添加新元素
语法：集合.add(元素)，将指定元素，添加到集合内
结果：集合本身被修改，添加了新元素

- 移除元素
语法：集合.remove(元素)，将指定元素，从集合内移除
结果：集合本身被修改，移除了元素

- 从集合中随机取出元素
语法：集合.pop(),功能，从集合中随机取出一个元素
结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

- 清空集合
语法：集合.clear(),功能，清空集合
结果：集合本身被清空

- 取出2个集合的差集
语法：集合1.difference(集合2)
功能：取出集合1和集合2的差集（集合1有而集合2没有的）
结果：得到一个新集合，集合1和集合2不变

- 消除2个集合的差集
语法：集合1.difference_update(集合2)
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
结果：集合1被修改，集合2不变

- 2个集合合并
语法：集合1.union(集合2)
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变
"""

# 定义集合
my_set = {"张三","李四","王五","肥六","田七","张三","李四","王五","张三"}
my_set_empty = set() # 定义空集合
print(f"my_set的内容是：{my_set},类型是：{type(my_set)}")
print(f"my_set_empty的内容是：{my_set_empty}，类型是：{type(my_set_empty)}")

# 添加新元素
my_set.add("sunwukong")
my_set.add("tangseng")
print(f"my_set添加元素后结果是：{my_set}")

# 移除元素
my_set.remove("张三")
print(f"my_set移除张三后，结果是：{my_set}")

# 随机取出一个元素
my_set = {"张三","李四","王五","肥六","田七","张三","李四","王五","张三"}
element = my_set.pop()
print(f"集合被取出元素是：{element},取出元素后：{my_set}")

# 清空元素,clear
my_set.clear()
print(f"集合被清空了，结果是：{my_set}")

# 取2个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(f"取出差集后的结果：{set3}") # 取出差集后的结果：{2, 3}
print(f"取差集后，原有set1的内容：{set1}") # 取差集后，原有set1的内容：{1, 2, 3}
print(f"取差集后，原有set2的内容：{set2}") # 取差集后，原有set2的内容：{1, 5, 6}

# 消除2个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference_update(set2)
print(f"消除差集后，集合1结果：{set1}") # 消除差集后，集合1结果：{2, 3}
print(f"消除差集后，集合2结果：{set2}") # 消除差集后，集合2结果：{1, 5, 6}

# 2个集合合并为1个
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(f"2集合合并后的结果：{set3}") # 2集合合并后的结果：{1, 2, 3, 5, 6}
print(f"合并后集合1：{set1}") # 合并后集合1：{1, 2, 3}
print(f"合并后集合2：{set2}") # 合并后集合2：{1, 5, 6}

# 统计集合元素数量
set1 = {1,2,3,4,5,1,2,3,4,5}
num = len(set1)
print(f"集合内的元素数量有：{set1}") # 集合内的元素数量有：{1, 2, 3, 4, 5}

# 集合遍历
# 集合不支持下标索引，不能用while循环，可以使用for循环
set1 = {1,2,3,4,5}
for element in set1:
    print(f"集合的元素有：{element}")

"""
经过上述对集合的学习，可以总结出集合有如下特点：
    - 可以容纳多个数据
    - 可以容纳不同类型的数据（混装)
    - 数据是无序存储的（不支持下标索引）
    - 不允许重复数据存在
    - 可以修改（增加或删除元素等）
    - 支持for循环
"""

"""
信息去重
有如下列表对象：
my_list=['黑马程序员'，'传智播客'，'黑马程序员'，'传智播客'，'itheima','itcast','itheima','itcast','best']
请：
- 定义一个空集合
- 通过for循环遍历列表
- 在for循环中将列表的元素添加至集合
- 最终得到元素去重后的集合对象，并打印输出
"""
"""
演示集合信息去重
"""
my_list = ['黑马程序员','传智播客','黑马程序员','传智播客','itheima','itcast','itheima','itcast','best']
# 定义一个空集合
my_set = set()

# 通过for循环遍历列表
for element in my_list:
    # 在for循环中将列表的元素添加至集合
    my_set.add(element)

# 最终得到元素去重后的集合对象，并打印输出
print(f"列表的内容是：{my_list}")
print(f"通过for循环后，得到的集合对象是：{my_set}")

6.8 dict字典

"""
字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：
#定义字典字面量
{key:value,key:value,......key:value}
#定义字典变量
my_dict {key:value,key:value,......key:value}
#定义空字典
my_dict = {}  #空字典定义方式1
my_dict = dict()  #空字典定义方式2
"""

"""
演示数据容器字典的定义
- 字典数据的获取
字典同集合一样，不可以使用下标索引，但是字典可以通过Key值来取得对应的Value。
"""
# 定义字典
my_dict1 = {"孙悟空":99,"唐僧":100,"猪八戒":88,"沙和尚":77}

# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是:{my_dict1},类型：{type(my_dict1)}")
print(f"字典2的内容是:{my_dict2},类型：{type(my_dict2)}")
print(f"字典3的内容是:{my_dict3},类型：{type(my_dict3)}")

# 定义重复key的字典
my_dict1 = {"孙悟空":99,"孙悟空":100,"猪八戒":88,"沙和尚":77}
print(f"重复key的字典内容是：{my_dict1}") # 重复key的字典内容是：{'孙悟空': 100, '猪八戒': 88, '沙和尚': 77}

# 从字典中基于key获取value
my_dict1 = {"孙悟空":99,"唐僧":100,"猪八戒":88,"沙和尚":77}
score = my_dict1["孙悟空"]
print(f"孙悟空的考试分数是：{score}")

"""
- 字典的嵌套
字典的Key和Value可以是任意数据类型(Key不可为字典)
那么，就表明，字典是可以嵌套的
需求如下：记录学生各科的考试信息
"""
# 定义嵌套字典
stu_score_dict = {
    "孙悟空":{
        "语文":77,
        "数学":66,
        "英语":33
    },
    "唐僧":{
        "语文": 88,
        "数学": 86,
        "英语": 55
    },
    "猪八戒":{
        "语文": 99,
        "数学": 87,
        "英语": 67
    }
}
print(f"学生的考试信息是：{stu_score_dict}")

# 从嵌套字典中获取数据
score = stu_score_dict["孙悟空"]["语文"]
print(f"孙悟空的语文分数是：{score}")
score = stu_score_dict["猪八戒"]["英语"]
print(f"猪八戒的英语分数是：{score}")

"""
字典的注意事项
    - 键值对的Key和Value可以是任意类型(Key不可为字典)
    - 字典内Key不允许重复，重复添加等同于覆盖原有数据
    - 字典不可用下标索引，而是通过Key检索Value
"""

6.9 dict字典常用操作

"""
- 新增元素
语法：字典[Key]=Value,结果：字典被修改，新增了元素

- 更新元素
语法：字典[Key]=Value,结果：字典被修改，元素被更新
注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

- 删除元素
语法：字典.pop(Key),结果：获得指定Key的Value,同时字典被修改，指定Key的数据被删除

- 清空字典
语法：字典.clear(),结果：字典被修改，元素被清空

- 获取全部的key
语法：字典keys()结果：得到字典中的全部Key
"""

"""
演示字典的常用操作
"""
my_dict = {"孙悟空":99,"唐僧":100,"猪八戒":88,"沙和尚":77}
# 新增元素
my_dict["白龙马"] = 66
print(f"字典经过新增元素后，结果是：{my_dict}")

# 更新元素
my_dict["猪八戒"] = 33
print(f"字典经过更新后，结果是：{my_dict}")

# 删除元素
score = my_dict.pop("猪八戒")
print(f"字典中被移除了一个元素，结果：{my_dict}，猪八戒的考试分数是：{score}")

# 清空元素，clear
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")

# 获取全部的key
my_dict = {"孙悟空":99,"唐僧":100,"猪八戒":88,"沙和尚":77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")

# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是：{key}")
    print(f"字典的value是：{my_dict[key]}")

# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(f"2字典的key是：{key}")
    print(f"2字典的vlaue是：{my_dict[key]}")

# 统计字典内的元素数量,len()函数
num = len(my_dict)
print(f"字典中的元素数量有：{num}个")

"""
经过上述对字典的学习，可以总结出字典有如下特点：
    - 可以容纳多个数据
    - 可以容纳不同类型的数据
    - 每一份数据是KeyValue键值对
    - 可以通过Key获取到Value,Key不可重复（重复会覆盖）
    - 不支持下标索引
    - 可以修改（增加或删除更新元素等）
    - 支持for循环，不支持while循环
"""

"""
升职加薪
有如下员工信息，请使用字典完成数据的记录。
并通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元
"""
"""
演示字典的课后练习：升职加薪，对所有级别为1级的员工，级别上升1级，薪水增加1000元
"""

# 组织字典记录数据
info_dict ={
    "王力鸿":{
        "部门":"科技部",
        "工资":3000,
        "级别":1
    },
    "周杰轮":{
        "部门":"市场部",
        "工资":5000,
        "级别":2
    },
    "林俊节":{
        "部门":"市场部",
        "工资":7000,
        "级别":1
    },
    "张学油":{
        "部门":"科技部",
        "工资":4000,
        "级别":1
    },
    "刘德滑":{
        "部门":"市场部",
        "工资":6000,
        "级别":2
    }
}
# for循环遍历字典
for name in info_dict:
    # if条件判断符合条件员工
    if info_dict[name]["级别"] == 1:
        # 升职加薪操作
        # 获取到员工的信息字典
        employee_info_dict = info_dict[name]
        # 修改员工信息
        employee_info_dict["级别"] = 2 # 级别+1
        employee_info_dict["工资"] += 1000 # 工资+1000
        # 将员工的信息更新回info_dict
        info_dict[name] = employee_info_dict
# 输出结果
print(f"对员工进行升级加薪后的结果是：{info_dict}")

7.0 数据容器总结对比

"""
数据容器可以从以下视角进行简单的分类：
- 是否支持下标索引
    -- 支持：列表、元组、字符串一序列类型
    -- 不支持：集合、字典一非序列类型
- 是否支持重复元素：
    -- 支持：列表、元组、字符串一序列类型
    -- 不支持：集合、字典一非序列类型
- 是否可以修改
    -- 支持：列表、集合、字典
    -- 不支持：元组、字符串
"""

"""
基于各类数据容器的特点，它们的应用场景如下：
    - 列表：一批数据，可修改、可重复的存储场景
    - 元组：一批数据，不可修改、可重复的存储场景
    - 字符串：一串字符串的存储场景
    - 集合：一批数据，去重存储场景
    - 字典：一批数据，可用Key检索Value的存储场景
"""

7.1 数据容器的通用操作

"""
- 数据容器的通用操作-遍历
数据容器尽管各自有各自的特点，但是它们也有通用的一些操作。
首先，在遍历上：
    -- 5类数据容器都支持for循环遍历
    -- 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）
尽管遍历的形式各有不同，但是，它们都支持遍历操作。

- 数据容器的通用统计功能
除了遍历这个共性外，数据容器可以通用非常多的功能方法
    -- len(容器)：统计容器的元素个数
    -- max(容器)：统计容器的最大元素
    -- min(容器)：统计容器的最小元素

- 容器的通用转换功能
除了下标索引这个共性外，还可以通用类型转换
    -- list(容器)：将给定容器转换为列表
    -- str(容器)：将给定容器转换为字符串
    -- tuple(容器)：将给定容器转换为元组
    -- set(容器)：将给定容器转换为集合

- 容器通用排序功能
通用排序功能
sorted(容器,[reverse:=True])
将给定容器进行排序
"""

"""
演示数据容器的通用功能
"""
my_list = [1,2,3,4,5]
my_tuple = (1,2,3,4,5)
my_str = "abcdefg"
my_set = {1,2,3,4,5}
my_dict = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}

# len元素个数
print(f"列表元素个数有：{len(my_list)}")
print(f"元组元素个数有：{len(my_tuple)}")
print(f"字符串元素个数有：{len(my_str)}")
print(f"集合元素个数有：{len(my_set)}")
print(f"字典元素个数有：{len(my_dict)}")

# max最大元素
print(f"列表元素个数有：{max(my_list)}")
print(f"元组元素个数有：{max(my_tuple)}")
print(f"字符串元素个数有：{max(my_str)}")
print(f"集合元素个数有：{max(my_set)}")
print(f"字典元素个数有：{max(my_dict)}")

# min最小元素
print(f"列表元素个数有：{min(my_list)}")
print(f"元组元素个数有：{min(my_tuple)}")
print(f"字符串元素个数有：{min(my_str)}")
print(f"集合元素个数有：{min(my_set)}")
print(f"字典元素个数有：{min(my_dict)}")

# 类型转换：容器转列表
print(f"列表转列表的结果是：{list(my_list)}")
print(f"元组转列表的结果是：{list(my_tuple)}")
print(f"字符串转列表结果是：{list(my_str)}")
print(f"集合转列表的结果是：{list(my_set)}")
print(f"字典转列表的结果是：{list(my_dict)}")

# 类型转换：容器转元组
print(f"列表转元组的结果是：{tuple(my_list)}")
print(f"元组转元组的结果是：{tuple(my_tuple)}")
print(f"字符串转元组结果是：{tuple(my_str)}")
print(f"集合转元组的结果是：{tuple(my_set)}")
print(f"字典转元组的结果是：{tuple(my_dict)}")

# 类型转换：容器转字符串
print(f"列表转字符串的结果是：{str(my_list)}")
print(f"元组转字符串的结果是：{str(my_tuple)}")
print(f"字符串转字符串结果是：{str(my_str)}")
print(f"集合转字符串的结果是：{str(my_set)}")
print(f"字典转字符串的结果是：{str(my_dict)}")

# 类型转换：容器转集合
print(f"列表转集合的结果是：{set(my_list)}")
print(f"元组转集合的结果是：{set(my_tuple)}")
print(f"字符串转集合结果是：{set(my_str)}")
print(f"集合转集合的结果是：{set(my_set)}")
print(f"字典转集合的结果是：{set(my_dict)}")

# sorted排序
my_list = [3,2,1,4,5]
my_tuple = (5,2,1,4,5)
my_str = "abcdefg"
my_set = {1,5,4,3,2}
my_dict = {"key1":1,"key3":3,"key2":2,"key4":4,"key5":5}

print(f"列表对象的排序结果是：{sorted(my_list)}")
print(f"元组对象的排序结果是：{sorted(my_tuple)}")
print(f"字符串对象的排序结果是：{sorted(my_str)}")
print(f"集合对象的排序结果是：{sorted(my_set)}")
print(f"字典对象的排序结果是：{sorted(my_dict)}")

print(f"列表对象的反向排序结果是：{sorted(my_list,reverse=True)}")
print(f"元组对象的反向排序结果是：{sorted(my_tuple,reverse=True)}")
print(f"字符串对象的反向排序结果是：{sorted(my_str,reverse=True)}")
print(f"集合对象的反向排序结果是：{sorted(my_set,reverse=True)}")
print(f"字典对象的反向排序结果是：{sorted(my_dict,reverse=True)}")

7.2 字符串比较大小

"""
- ASCII码表
在程序中，字符串所用的所有字符如：
    -- 大小写英文单词
    -- 数字
    -- 特殊符号(！、\、、@、#、空格等)
都有其对应的ASCII码表值
每一个字符都能对应上一个：数字的码值
字符串进行比较就是基于数字的码值大小进行比较的。

- 字符串比较
    -- 字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大。
"""

"""
演示字符串大小比较
"""
# abc 比较 abd
print(f"abc大于abd，结果是：{'abd' > 'abc'}")

# a 比较 ab
print(f"ab大于a，结果是：{'ab' > 'a'}")

# a 比较 A
print(f"a大于A，结果是：{'a' > 'A'}")

# key1 比较 key2
print(f"key1 > key2，结果是：{'key2' > 'key1'}")

总结：
1.字符串如何比较

• 从头到尾，一位位进行比较，其中一位大，后面就无需比较了。

2.单个字符之间如何确定大小？

• 通过ASCI川码表，确定字符对应的码值数字来确定大小。

第七章 函数多返回值及参数传递