2022黑马Python学习笔记
Posted POLA_desu
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了2022黑马Python学习笔记相关的知识，希望对你有一定的参考价值。
一、导学
- Pthon语言基础入门
- Pthon语言高阶加强
- 大数据分析PySpark
二、 初识Python
- 你好Python程序
print("Hello World!!")
>>Hello World!!
！输入的双引号和括号为英文字符
三、 Python基础语法
（一） 字面量
1. 定义：在代码中，被写下来的固定的值，称之为字面量。
2. 常用的6种值的类型
| 类型 | 描述 | 说明 |
| 数字（Number） | 支持（4种子类型）
|
|
| 字符串（String） | 描述文本的一种数据类型 | 字符串（string）由任意数量的字符组成 |
| 列表（List） | 有序的可变序列 | Python中使用最频繁的数据类型，可有序记录一堆数据 |
| 元组（Tuple） | 有序的不可变序列 | 可有序记录一堆不可变的Python数据集合 |
| 集合（Set） | 无序不重复集合 | 可无序记录一堆不重复的Python数据集合 |
| 字典（Dictionary） | 无序Key-Value集合 | 可无序记录一堆Key-Value型的Python数据集合 |
3. 字符串
！Python中，字符串需要用双引号包围；
！被双引号包围的都是字符串
666
13.14
"黑马程序员"
print( 666 )
print( 13.14 )
print( "黑马程序员" )
>>666
>>13.14
>>"黑马程序员"（二） 注释
1. 单行注释
# 我是单行注释
print( "黑马程序员" )！规范：#号和注释内容一般建议以一个空格隔开
2. 多行注释
"""
我是多行注释
666
13.14
"黑马程序员"
"""
print( 666 )
print( 13.14 )
print( "黑马程序员" )（三） 变量
1. 定义：程序运行时，能储存计算结果或表示值的抽象概念。
简单的说，变量就是在程序运行时，记录数据用的
2.定义格式：
变量名称 = 变量的值
# 定义变量
money = 5000
# print输出变量
print( " 钱包还有：" , money )
>> 钱包还有： 5000
# 买了东西，花费10元
money = money - 10
print( "买了冰淇淋花费10元，还剩余：" , money , "元" )
>>买了冰淇淋花费10元，还剩余： 4990 元！变量值可变
$练习：
（四） 数据类型
1. type()语句【具有返回值】
1）语法：
type(被查看类型的数据)
2）使用方法：
a = type( 666 )
print( a )
print( type( 13.14 ) )
name = "黑马程序员"
name_type = type( name )
print( name_type )
>> <class 'int'>
>> <class 'float'>
>> <class 'str'>2. 变量无类型，查看变量的类型实际上查看的是变量存储数据的类型
！字符串变量：不是字符串是变量，而是变量存储了字符串
（五） 数据类型转换
1. 常见的转换语句
| 语句（函数） | 说明 |
| int( x ) | 将x转换为一个整数 |
| float( 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 )
>> <class 'str'> 11
>> <class 'str'> 13.14# 将字符串类型 -> 数字类型
num = int( "11" )
print( type( num ) , num )
num2 = float( "13.14" )
print( type( float ) , num2 )
>> <class 'int'> 11
>> <class 'float'> 13.14！想要将字符串转换成数字，必须要求字符串内的内容都是数字
num3 = int ( "黑马程序员" )
print( type( num3 ) , num3 )
>> ValueError: invalid literal for int() with base 10: '黑马程序员'！浮点数转整数会丢失精度
# 整数 -> 浮点数
float_num = float( 11 )
print( type( float_num ) , float_num )
>> <class 'float'> 11.0
# 浮点数 -> 整数
int_num = int( 13.14 )
print( type( int_num ) , int_num )
>> <class 'int'> 13（六）标识符
1. 定义：用户在编程时所用的一系列名字，用于给变量、类、方法等命名。
2. 命名规则：
内容限定（英文，中文，数字，下划线_）
！数字不可开头
大小写敏感
不可使用关键字
3. 命名规范：
见名知义
下划线命名法
英文字母全小写
（七） 远算符
1. 算术运算符：+、-、*、/、//、%、**（指数）
2. 赋值运算符：=
3. 复合赋值运算符：+=、-=、*=、/=、//=、%=、**=
（八） 字符串扩展
1. 3种定义方式
1）定义形式：
① 单引号定义法：
name = '黑马程序员'
②双引号定义法：
name = "黑马程序员"
③三引号定义法：
name = """黑马程序员"""
*支持换行操作，使用变量接收它，则为字符串；不使用变量接收，则为多行注释
# 单引号定义法，使用单引号进行包围
name = '黑马程序员'
print( type(name) )
# 双引号定义法，写法和多行注释是一样的
name = "黑马程序员"
print( type(name) )
# 三引号定义法，写法和多行注释是一样的
name = """
我是
黑马
程序员
"""
print( type(name) )
>> <class 'str'>
>> <class 'str'>
>> <class 'str'>
2）字符串的引号嵌套
①单引号法，可以内含双引号；
②双引号定义法，可以内含单引号；
②可以使用转义字符（\\）来将引号解除效用，变成普通字符串。
# 字符串内，包含双引号
name = '"黑马程序员"'
print( name )
# 字符串内，包含单引号
name = "'黑马程序员'"
print( name )
# 使用转义字符（\\）解除引号的效用
name = "\\"黑马程序员\\""
print( name )
name = '\\'黑马程序员\\''
print( name )
>> "黑马程序员"
>> '黑马程序员'
>> "黑马程序员"
>> '黑马程序员'2. 字符串拼接
1）通过+号进行拼接
name = "黑马程序员"
print( "我的名字是：" + name + "我可以教大家IT技能" )
>> 我的名字是：黑马程序员我可以教大家IT技能！无法和非字符串类型进行拼接
3. 字符串格式化
1）“%占位符”%变量
2）常用占位符
字符串：%s
整数： %d
浮点数：%f
3）数字精度控制
辅助符号“m.n”来控制数据的宽度和精度
m ：控制宽度，要求是数字（很少使用），设置的宽度小于数字本身，不生效
.n：控制小数点精度，要求是数字，会进行小数的四舍五入
%5d：表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成：[空格][空格][空格]11，用三个空格补足宽度
%5.2f：表示将宽度控制为5，将小数点精度设置为2
小数点和小数部分也算入宽度计算。如：对11.345设置为%7.2后，结果是：[空格][空格]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 )
>> 数字11宽度限制5，结果： 11 # 宽度5，补了3个空格
>> 数字11宽度限制1，结果：11 # 宽度小于数字本身，无影响
>> 数字11.345宽度限制7，小数精度2，结果： 11.35
# 宽度7，补了2个空格，小数精度2，四舍五入后为.35
>> 数字11.345不限制宽度，小数精度2，结果：11.35
# 不限制宽度，小数点后四舍五入后为.354）快速写法
语法：
f"内容变量"
name = "传智播客"
set_up_year = 2006
stock_price = 19.99
print( f"我是name，我成立于set_up_year。我今天的股票价格是：stock_price" )
>> 我是传智播客，我成立于2006。我今天的股票价格是：19.99
# 不做精度控制，原样输出！以上字符串格式化均可用于表达式格式化
print( "1 * 1的结果是：%d" % ( 1 * 1 ) )
print( f"1 * 1的结果是：1 * 1")
print( "字符串在Python中的类型是：%s" % type('字符串') )
>> 1 * 1的结果是：1
>> 1 * 1的结果是：1
>> 字符串在Python中的类型是：<class 'str'>$练习：
（九）数据输入
1. 语法
input();
2. 使用：
使用input()语句可以从键盘获取输入
使用一个变量接收（存储）input语句获取的键盘输入数据即可
数据输出：print
数据输入：input
print( "请告诉我你是谁？" )
name = input()
print( "GET！！你是：%s" % name )
>> 请告诉我你是谁？
>> XUANseyo
>> GET！！你是：XUANseyo! input()语句可以在要求使用者输入内容之前，输出提示内容的
name = input( "你是谁？" )
print( "GET！！你是：%s" % name )
>> 你是谁？XUANseyo
>> GET！！你是：XUANseyo！无论input()输入什么，其都会自动转为字符串类型，我们要自行进行数据类型转换
num = input( "你的银行卡密码是：" )
print( "你的银行卡密码的类型是：" , type( num ) )
>> 你的银行卡密码是：123456
>> 你的银行卡密码的类型是： <class 'str'>$练习：
四、 Python判断语句
（一） 布尔类型和比较运算符
1. 布尔类型：判断结果
True：表示真（是、肯定）
False：表示假（否、否定）
# 定义变量存储布尔类型的数据
bool_1 = True
bool_2 = False
print( f"bool_1变量的内容是： bool_1 ，类型为： type( bool_1 ) " )
print( f"bool_2变量的内容是： bool_2 ，类型为： type( bool_2 ) " )
>> bool_1变量的内容是：True，类型为：<class 'bool'>
>> bool_2变量的内容是：False，类型为：<class 'bool'>2. 比较运算和比较运算符：
==、!=、>、<、>=、<=
（二） if语句的基本格式
1. if语句基本格式：
if 要判断的条件：
条件成立时，要做的事情
！首行缩进确定代码块归属
age = 30
if age >= 18:
print( "我已经成年了。" )
print( f"已经 age 岁了啊！" )
print( "时间过得真快啊！" )
>> 我已经成年了。
>> 已经30岁了啊！
>> 时间过得真快啊！# 判断语句的结果必须为布尔类型的True或False
True会执行if内的代码语句
False则不会执行
age = 10
if age >= 18:
print( "我已经成年了。" )
print( f"已经 age 岁了啊！" )
print( "时间过得真快啊！" )
>> 时间过得真快啊！$练习：
（三） if else 语句
1. 基本格式：
if 条件 ：
满足条件时要完成的事1
满足条件时要完成的事2
……
else：
不满足条件时要完成的事1
不满足条件时要完成的事2
……
print( "欢迎来到黑马儿童游乐场，儿童免费，成人收费！" )
age = input( "请输入您的年龄：" )
if int(age) >= 18 :
print( "您已成年，游玩需补票10元" )
else :
print( "您未成年，无需补票" )
print( "祝您游玩愉快！！！" )
>> 欢迎来到黑马儿童游乐场，儿童免费，成人收费！
>> 请输入您的年龄：17
>> 您未成年，无需补票
>> 祝您游玩愉快！！！ $练习： 
（四） if elif else 语句
1. 基本格式：
if 条件1 :
条件1满足时要完成的事
条件1满足时要完成的事
……
elif 条件2::
条件2满足时要完成的事
条件2满足时要完成的事
……
elif 条件n:
条件n满足时要完成的事
条件n满足时要完成的事
……
else:
所有条件不满足时要完成的事
所有条件不满足时要完成的事
……
print("欢迎来到黑马动物园！！")
height = int(input("请输入你的身高："))
vip_level = int(input("请输入您的vip级别（1~5）："))
if height < 120 :
print("您的身高小于120cm，可以免费游玩")
elif vip_level > 3 :
print("您的vip级别大于3，可以免费游玩")
else :
print("不好意思，所有条件均不符合，需要购票10元")
print("祝您游玩愉快")
>> 欢迎来到黑马动物园！！
>> 请输入你的身高：150
>> 请输入您的vip级别（1~5）：5
>> 您的vip级别大于3，可以免费游玩
>> 祝您游玩愉快$练习：
（五） 判断语句的嵌套
1. 基本格式
if 条件1 ：
满足条件1时要完成的事1
满足条件1时要完成的事2
……
if条件2：
满足条件2做的事情1
满足条件2做的事情2
……
2. 嵌套的关键点：空格缩进
通过空格缩进，来决定语句之间的：层次关系
（六） 实战案例
import random
num = random.randint(1,10)
m = int(input("第一次才得数字："))
if num == m :
print ("猜对啦！")
else :
if num > m:
print("猜小了！")
else :
print("猜大了！")
m2 = int(input("第二次猜测的数字："))
if m2 == num:
print("第二次猜对了！")
elif num > m2:
print("第二次猜小了！")
elif num < m2:
print("第二次猜大了")
guess_num = int(input("第三次输入你要猜测的数字："))
if guess_num == num:
print("第三次猜中了")
else:
print("三次机会用完了，没有猜中。")五、 Python循环语句
（一） while循环的基本语法
1. 基本格式
while 条件：
条件满足时，做的事情1
条件满足时，做的事情2
…（省略）…
- 只要条件满足，会无限循环执行
- 条件需要布尔类型结果
$练习：
（二） while循环的基础案例
（三） while循环的嵌套应用
1. 基本格式：
while 条件1：
条件1满足时，做的事情1
条件1满足时，做的事情2
…（省略）…
while 条件2：
条件2满足时，做的事情1
条件2满足时，做的事情2
…（省略）…
（四） while循环的嵌套应用
补充：
1. print输出不换行
print("Hello",end=' ')
print("World!",end='')
>> Hello World!2. 制表符/t
print("学号\\t姓名\\t语文\\t数学\\t英语")
print("2022001\\t小王\\t99\\t\\t88\\t\\t0")
print("2022002\\t小周\\t92\\t\\t45\\t\\t93")
print("2022008\\t小黄\\t77\\t\\t82\\t\\t100")
（五） for循环的基础语法
1. 基础语法
for循环就是将“待办事项”逐个完成的循环机制
- while循环的循环条件是自定义，自行控制循环条件
- for循环是一种“轮询”机制，是对一批内容进行逐个处理
！for循环无法定义循环条件，只能从被处理的数据集中，依次取出内容进行处理
1） 基本格式：
for 临时变量 in 待处理的数据集：
循环满足条件时执行的语句
$练习：
2. range语句
1） 功能：获得一个数字序列（可迭代类型的一种）
2） 语法格式：
range（num）
获取一个从0开始，到num结束的数字序列
range（num1，num2）
获取一个从num1开始，到num2结束的数字序列（不含num2本身）
range（num1，num2，step）
获得一个从num1开始，到num2结束的数字序列（不含num2本身）
数字之间的步长，以step为准（step默认为1）
$练习：
3. 变量作用域
（六）for循环的嵌套应用
1. 基本格式：
for 临时变量 in 待处理的数据集：
循环满足条件时执行的语句1
循环满足条件时执行的语句2
……
for 临时变量 in 待处理的数据集：
循环满足条件时执行的语句1
循环满足条件时执行的语句1
$练习：
（七） 循环中断：break和continue
1. continue关键字作用：中断本次循环，直接进入下一次循环【for循环和while循环即可使用】
2. break关键字作用：所在循环永久中断【for循环和while循环即可使用】
（八） 综合案例
六、 Python函数
（一） 函数介绍
1. 函数：是组织好的，可重复使用的，用来实现特定功能的代码段。
eg. len()：实现统计长度这一特定功能的代码段。
2. 函数好处：
* 将功能封装在函数内，可随时随地重复利用
* 提高代码的复用性，减少重复代码，提高开发效率
（二） 函数定义
1. 基本语法：
（1） 函数定义
def 函数名 （传入函数）：
函数体
return 返回值
（2） 函数调用
函数名（参数）
！参数可省略
！返回值可省略
！函数必须先定义后使用
$练习：
def printWelcome ():
print("欢迎来到黑马程序员！")
print("请出示48小时核酸检测证明！")
printWelcome()（三） 函数参数
1. 传入参数的功能：在函数调用时，接受外部提供的数据
！参数之间按顺序传入；使用，进行分隔
$练习：
def printWelcome(x):
print("欢迎来到黑马程序员！请出示48小时核酸检测证明！")
if x <= 37.5:
print(f"体温测量中，您的体温是：x，体温正常，请进！")
else:
print(f"体温测量中，您的体温是x，需要隔离！")
y = int(input("请输入您的体温："))
printWelcome(y)
（四） 函数返回值
1. 通过return关键字，可向调用者返回数据
2.. None类型：
（1） None，其类型是<class ’NoneType’>
（2） 无返回值的函数，实际上是返回了None这个字面量
（3） 使用：
- 用于函数返回值中【空】
- 用于if判断【None等同于False】
- 用于声明无内容的变量上
（五） 函数说明文档
1. 函数说明文档：对函数进行说明解释，帮助更好地理解函数
2.. 定义语法：
def func（x，y）
"""
函数说明
：param x：参数x的说明
：param x：参数x的说明
：return：返回值的说明
"""
函数体
return 返回值
（六） 函数嵌套使用
1. 函数嵌套：在一个函数中，调用另一个函数。
2. 执行流程：
函数a中执行到调用函数b的语句，会将b全部执行；完成后，继续执行函数a的剩余内容
（七） 变量的作用域
1. 变量作用域：变量的作用范围
2.. 局部变量：定义在函数体内部的变量，只在函数体内部生效
局部变量作用：在函数体内部，临时保存数据，即当函数调用完成后，销毁局部变量
3. 全局变量：在函数体内外都能生效的变量
4. global关键字：可使函数内部声明变量为全局变量
（八） 综合案例
money = 5000000
name = None
def menu():
name = input("您好！请输入客户姓名：")
print("您好，请问您需要什么服务呢？")
print("输入1：查询余额")
print("输入2：存款")
print("输入3：取款")
n = int(input("请输入功能号："))
if n == 1:
check(money)
elif n == 2:
x = int(input("请输入您想存入的金额："))
deposit(x, money)
elif n == 3:
y = int(input("请输入您想取出的金额："))
withdraw(y, money)
def check(money):
print(f"您好！您的余额为：money")
menu()
def deposit(x, money):
money1 = x + money
print(f"您好，存款成功后，您的余额为：money1")
menu()
def withdraw(x, money):
money2 = money - x
print(f"您好，取款成功后，您的余额为：money2")
menu()
menu()七、 Python数据容器
（一） 数据容器入门
1. 数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素。每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
2.. 种类：list（列表）、tuple（元组）、str（字符串）、set（集合）、dict（字典）
（二） 数据容器：list（列表）
1. 定义
（1） 基本语法：
# 字面量
[元素1 ，元素2 ，元素3，……]
# 定义变量
变量名称 = [元素1 ，元素2 ，元素3，……]
# 定义空列表
变量名称 = []
变量名称 = list（）
（2） 元素：列表中的每个数据
！ 列表可以一次存储多个数据，且可以为不同类型，支持嵌套
2. 列表的下标索引
（1） 类型：正向：从前向后，从0开始，依次递增
反向：从后向前，从-1开始，依次递减
（2） 使用：
列表[下标]
！ 下标超出范围，则无法取出元素，并且会报错
3. 列表的常用操作（方法）
* 函数：封装的代码单元，可提供特定功能。
如将函数定义为class（类）的成员，则称函数为方法。
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | index | 列表.index（元素） | 查找指定元素在列表中的下标，找不到则报错ValueError |
| 2 | len | len（列表） | 统计容器中有多少元素 |
| 3 | count | 列表.count（元素） | 统计此元素在列表中出现的次数 |
| 4 | del | del 列表[下标] | 删除列表指定的下标元素 |
| 5 | pop | 列表.pop[下标] | 删除列表指定的下标元素 |
| 6 | remove | 列表.remove（元素） | 从前向后，删除此元素的第一个匹配项 |
| 7 | append | 列表.append（元素） | 向列表中追加一个元素 |
| 8 | extend | 列表.extend（容器） | 将数据容器中的内容依次取出，追加到列表尾部 |
| 9 | insert | 列表.insert（下标，元素） | 在指定下标处，插入指定的元素 |
| 10 | clear | 列表.clear（） | 清空列表 |
4. 列表的特点
- 可容纳多个元素
- 可容纳不同类型的元素
- 数据是有序存储的
- 允许重复数据存在
- 可进行增删查改
$练习：
age = [21, 25, 21, 23, 22, 20]
age.append(31)
print(age)
age.extend([29, 33, 30])
print(age)
x = age[0]
y = age[-1]
print(x, y)
a = age.index(31)
print(a)（三） list（列表）的遍历
* 遍历：将容器内的元素依次取出，并处理
1. 使用while遍历
- 可以指定循环条件，自行控制
- 可以通过条件控制做到无限循环
- 适用于任何想要循环的场景
2. 使用for遍历
- 不可以指定循环条件，只可以一个个从容器内取出数据
- 理论上不可以无限循环，因为被遍历的容器容量不是无限的
- 适用于遍历数据容器的场景或简单的固定次数循环场景
$练习：
L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
l1 = list()
l2 = list()
i = 0
# 取出偶数
while i < len(L):
if L[i] % 2 == 0:
l1 . append(L[i])
i = i + 1
else:
i = i + 1
print(f"通过while循环，从列表：L，中取出偶数，组成新列表l1")
for j in L:
if j % 2 == 0:
l2 . append(j)
print(f"通过for循环，从列表：L，中取出偶数，组成新列表l2")（四） 数据容器：tuple（元组）
* 元组一旦定义，不可进行修改
1. 元组的定义
（1） 基本语法：
# 字面量
（元素1 ，元素2 ，元素3，……）
# 定义变量
变量名称 =（元素1 ，元素2 ，元素3，……）
# 定义空列表
变量名称 = （）
变量名称 =tuple（）
！ 元组即使只含有一个数据，这个数据后也要添加，也可进行嵌套
2. 元组的操作（方法）
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | index | index（） | 查找指定数据在元组中的下标，找不到则报错 |
| 2 | len | len（元组） | 统计元组内有多少元素 |
| 3 | count | count（） | 统计某个数据在元组中出现的次数 |
！ 不可修改元组内容，否则直接报错
！ 可修改元组内list的内容
！ 不可以替换元组内list为其他list或其他类型
3. 元组的特点
- 可容纳多个元素
- 可容纳不同类型的元素
- 数据是有序存储的
- 允许重复数据存在
- 可进行增删查改
- 可进行循环
- 不可修改
$练习：
T = ('周杰伦', 11, ['football', 'music'])
a = T.index(11)
n = T[0]
print(a,n)
del T[2][0]
T[2].append('coding')
print(T)（五） 数据容器：str（字符串）
1. 字符串
字符的容器，一个字符串可以存放任意数量的字符。
2. 字符串的下标（索引）
- 从前向后，下标从0开始
- 从后向前，下标从-1开始
！ 字符串是一个无法修改的数据容器
！ 如果要修改，则会得到一个新的字符串，旧的字符串是无法修改的
3. 字符串的常用操作
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | 字符串[下标] | 根据下标索引取出特定位置字符 | |
| 2 | index | 字符串.index（字符串） | 查找给定字符的第一个匹配项的下标 |
| 3 | replace | 字符串.replace（字符串1，字符串2） | 将字符串内的全部字符串1，替换为字符串2 ！不会改变原字符串，而是得到一个新的字符串 |
| 4 | split | 字符串.split（字符串） | 按照给定字符串，对字符串进行分割 ！不会改变原字符串，而是得到一个新的列表 |
| 5 | strip | 字符串.strip（） 字符串.strip（字符串） | 移除首尾的空格和换行符或指定字符串 |
| 6 | count | 字符串.count（字符串） | 统计字符串内某字符串的出现次数 |
| 7 | len | len（字符串） | 统计字符串的字符个数 |
4. 字符串的特点
- 只可以存储字符串
- 长度任意
- 支持下标索引
- 允许重复的字符串出现
- 不可以修改
- 支持循环
$练习：
S = "itheima itcast boxuegu"
n = S.count("it")
print(f"字符串S中有n个it字符")
S1 = S.replace(" ", "|")
print(f"字符串S，被替换空格后，结果S1")
L = S1.split("|")
print(f"字符串S，按照“|”分割后，得到L")（六） 数据容器的切片
1. 序列
内容连续、有序、可使用下标索引的一类数据容器。（如列表、元组、字符串等）
2. 切片
（序列的常用操作）从一个序列中，取出一个子序列
3. 基本语法
序列[起始下标：结束下标：步长]
* 表示从序列中，从指定位置开始，依次取出指定元素，到指定位置结束，得到一个新序列
* 起始下标表示从何处开始，可以留空，留空视作从头开始
* 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
* 步长表示，依次取元素的间隔
- 步长1表示，一个个取元素
- 步长2表示，每次跳过1个元素取
- 步长N表示，每次跳过N-1个元素取
- 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
$练习：
S = "万过薪月，员序程马黑来，nohtyP学"
# 使用“切片”
new_S = S[9:4:-1]
print(new_S)
# 使用字符串常用操作
i = -9
S1 = S.replace("来", "")
S2 = S1.split(",")
print(S2)
new_S1 = S2[0][9:4:-1]
print(new_S1)
（七） 数据容器：set（集合）
1. 集合的基本语法
# 定义集合字面量
（元素，元素，……，元素）
# 定义集合变量
变量名称 = 元素，元素，……，元素
# 定义空集合
变量名称 = set（）
！ 去重且无序，无法保证顺序与创建的时候一致
！ 不支持：下标索引访问，因此不支持while循环
补充：
定义：
列表[] 可修改、支持重复元素且有序
元组（） 不可修改、支持重复元素且有序
字符串“” 不可修改、支持重复元素且有序
集合 可修改、不支持重复元素、无序
2. 集合的常用功能
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | add | 集合.add（元素） | 集合内添加一个元素 |
| 2 | remove | 集合.remove（元素） | 移除集合内指定的元素 |
| 3 | pop | 集合.pop（） | 从集合中随机取出一个元素 |
| 4 | clear | 集合.clear（） | 将集合清空 |
| 5 | difference | 集合1.difference（集合2） | 得到一个新集合，内含2个集合的差集 原有的2个集合内容不变 |
| 6 | update | 集合1.difference_update（集合2） | 在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变 |
| 7 | union | 集合1.union（集合2） | 得到1个新集合，内含2个集合的全部元素原有的2个集合内容不变 |
| 8 | len | len（集合） | 得到一个整数，记录了集合的元素数量 |
3. 集合的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据（混装）
- 数据是无序存储的（不支持下标存储）
- 不允许重复数据存在
- 可以修改
- 支持for循环，不支持while循环
$练习：
my_list = ['黑马程序员','传智播客','黑马程序员','传智播客','itheima','itcast','itheima','itcast','best']
S = set()
for i in my_list:
S.add(i)
print(f"有列表：my_list")
print(f"存入集合后结果：S")（八） 数据容器：dict（字典、映射）
1. 字典的基本语法
# 定义字典字面量
key：value，key：value，……，key：value
# 定义字面变量
my_dict = key：value，key：value，……，key：value
# 定义空字典
my_dict =
my_dict = dict
！ 每个元素均为键值对，key和value可以为任意类型数据（key不可为字典）
！ key不可重复，重复会对原有数据覆盖
！ 不可以使用下标索引，但可通过key值取得对应的value，不可使用while循环
！ 字典可嵌套
2. 字典的常用操作
| 编号 | 关键字 | 使用方法 | 作用 |
| GDAL 笔记二：python for GDAL
2022黑马程序员最新MySQL笔记（01：数据库学习前言） |