012高级类型变量

目标:
1、列表
2、元组
3、字典
4、字符串
5、公共方法
6、高级变量

在python中，所有 非数字型变量 都有以下特点：
①都是一个 序列sequence，也可以理解为容器
②取值[]
③遍历for in
④计算长度、最大/最小值、比较、删除
⑤连接+ 和 重复*
⑥切片

一、列表
· List（列表）是python中使用 最频繁 的数据类型，在其他语言中通常叫做 数组
· 专门用于存储一串信息
· 列表用[]定义，数据 之间使用“，”分隔
· 列表的 索引 从0开始（索引 就是数据在 列表 中的位置编号，又可以被称为 下标）
如：name_list = [“zhangsan”,“lisi”,“wangwu”]

1、列表方法

name_list = ["zhangsan", "lisi", "wangwu"]

# 1、取值和取索引
# list index out of range - 列表索引超出范围
print(name_list[0])

# 知道数据的内容，想确定数据在列表中的位置
# 使用index方法需要注意，如果传递的数据不在列表中，程序会报错！
print(name_list.index("wangwu"))

# 2、修改
name_list[1] = "李四"
# list assigment index out of range
# 列表指定的索引超出范围，程序会报错！
# name_list[3] = "王小二"

# 3、增加
# append 方法可以向列表的末尾追加数据
name_list.append("王小二")
# insert 方法可以在列表的指定索引位置插入数据
name_list.insert(1, "李晓丹")
# extend 方法可以把其他列表中的完整内容，追加到当前列表的末尾
temp_list = ["孙悟空", "猪八戒", "沙师弟"]
name_list.extend(temp_list)

# 4、删除
# remove 方法可以从列表中删除指定的数据
name_list.remove("wangwu")
# pop 方法默认可以把列表中最后一个元素删除
name_list.pop()
# pop 方法可以指定要删除元素的索引
name_list.pop(3)
# clear 方法可以清空列表
name_list.clear()

print(name_list)

2、了解 del 关键字

name_list = ["张三", "李四", "王五"]

# (知道)使用 del 关键字(delete)删除列表元素
# 提示：在日常开发中，要从列表删除数据，建议使用列表提供的方法

# del 关键字本质上是用来将一个变量从内存中删除的
# 注意：如果使用 del 关键字将变量从内存删除
# 后续的代码就不能再使用这个变量了
del name_list[1]

print(name_list)

3、列表的数据统计

name_list = ["张三", "李四", "王五", "王小二", "张三"]
print(name_list)

# len(length 长度) 函数可以统计列表中元素的总数
list_len = len(name_list)
print("列表中包含 %d 个元素" % list_len)

# count 方法可以统计列表中某一个数据出现的次数
count = name_list.count("张三")
print("张三出现了 %d 次" % count)

# 从列表中删除数据(第一次出现的数据)
name_list.remove("张三")

print(name_list)

4、列表排序

name_list = ["zhangsan", "lisi", "wangwu", "wangxiaoer"]
num_list = [2, 5, 3, 8, 5]

# 升序
name_list.sort()
num_list.sort()

# 降序
name_list.sort(reverse=True)
num_list.sort(reverse=True)

# 逆序（反转）
name_list.reverse()
num_list.reverse()

print(name_list)
print(num_list)

5、迭代遍历
· 在python中，可以使用for循环遍历所有非数字类型的变量：列表、元组、字典 以及 字符串。

name_list = ["张三", "李四", "王五", "王小二"]

# 使用迭代从列表中依次获取数据
"""
顺序的从列表中依次获取数据，每一次循环过程中，数据都会保存在my_name这个变量中，
在循环体颞部可以访问到当前这一次获取到的数据
for 循环内部使用的变量 in 列表:
for my_name in name_list:
    
    循环内部针对列表元素进行操作
    print(my_name)
"""

for my_name in name_list:

    print("我的名字叫 %s" % my_name)

6、列表应用场景
· 尽管python的 列表 中可以 存储不同类型的数据
· 但是在开发中，更多的应用场景是：
①列表 存储相同类型的数据
②通过 迭代遍历，在循环内部，针对列表中的每一项元素，执行相同的操作。

二、元组
· Tuple（元组）与列表类似，不同之处在于元组的 元素不能修改
。元组 表示多个元素组成的序列
。元组 在 python 开发中，有特定的应用场景
· 用于存储 一串 信息，数据 之间使用“，”分隔
· 元组用（）定义
· 元组的 索引 从0开始
。索引 就是数据在 元组 中的位置编号

1、元组的定义
①创建空元组（一般不用）

info_tuple = (）

②元组中 只包含一个元素时，需要在元素后面添加逗号

info_tuple = (5,）

③定义元组

info_tuple = ("zhangsan", 15, 5, 23）

2、元组的常用操作

info_tuple = ("zhangsan", 13, 1.75, "zhangsan")

# 1、取值和取索引
# 取值——元组名[]
print(info_tuple[0])
# 取索引——元组名.index("内容")
# 已经知道数据的内容，希望知道数据在元组中的索引
print(info_tuple.index("zhangsan"))

# 2、统计计数
print(info_tuple.count("zhangsan"))
# 统计元组中包含元素的个数
print(len(info_tuple))

3、循环遍历
· 在python中，可以使用for循环遍历所有非数字类型的变量：列表、元组、字典 以及 字符串。
· 提示：在实际开发中，除非 能够确认元组中的数据类型，否则针对元组的循环遍历需求不是很多。

info_tuple = ("zhangsan", 45, 1.35)

# 使用迭代遍历元组
for my_info in info_tuple:

    # 使用格式字符串拼接 my_info 这个变量不方便
    # 因为元组中保存的数据类型通常是不同的
    print(my_info)

4、应用场景
· 尽管可以使用for in遍历 元组。
· 但是在开发中，更多的应用场景是：
。函数的 参数 和 返回值，一个函数可以接收 任意多个参数，或者 一次返回多个数据。
。格式字符串，格式化字符串后面的（）本质上就是一个元组。
。让列表不可以被修改，以保护数据安全。

info_tuple = ("小明", 21, 1.34)

# 格式化字符串后面的（）本质上就是元组
print("%s 年龄是 %d 身高是 %.2f" % info_tuple)

5、元组和列表之间的转换
· 使用 list 函数可以把元组转换成列表

list(元组)

· 使用 tuple 函数可以把列表转换成元组

tuple（列表）

三、字典
· 字典 是 除列表以外python中 最灵活 的数据类型
· 字典同样可以用来 存储多个数据
。通常用于存储用于描述 一个物体 的相关信息
· 和列表的区别
。列表 是 有序 的对象集合
。字典 是 有序 的对象集合
· 字典用{}定义

xiaoming = {"name":"小明","age":18,"gender":True,"height":1.75}

· 字典使用 键值对 存储数据，键值对之间使用",“分隔
。键key是索引
。值value是数据
。键 和 值 之间使用”:"分隔
。键必须是唯一的
。值 可以是任何数据类型，但 键 只能使用 字符串、数字 或 元组

1、字典的增删改查常用操作

xiaoming_dic = {"name": "小明"}

# 1、取值
print(xiaoming_dic["name"])
# 在取值的时候，如果指定的key不存在，程序会报错
# print(xiaoming_dic["name123"])

# 2、增加/修改
# 如果key不存在，会新增键值对
xiaoming_dic["age"] = 18
# 如果key存在，会修改已经存在的键值对
xiaoming_dic["name"] = "小小明"

# 3、删除
xiaoming_dic.pop("name")
# 在删除指定键值对时，如果指定的key不存在，程序会报错！
# xiaoming_dic.pop("name123")

print(xiaoming_dic)

2、字典的统计、合并、清空

xiaoming_dic = {"name": "小明",
                "age": 18}

# 1、统计键值对数量
print(len(xiaoming_dic))

# 2、合并字典
temp_dic = {"height": 75,
            "age": 20}
# 注意：如果被合并的字典中包含已经存在的键值对，会覆盖原有的键值对
xiaoming_dic.update(temp_dic)

# 3、清空字典
xiaoming_dic.clear()

print(xiaoming_dic)

3、字典的循环遍历

xiaoming_dic = {"name": "小明",
                "qq": 254225,
                "phone": 10086}

# 迭代遍历字典
# 变量k是每一次循环中，获取到的键值对key
for k in xiaoming_dic:

    print("%s - %s" %(k, xiaoming_dic[k])

4、字典和列表组合的应用场景
· 尽管可以使用for in 遍历 字典
· 但是在开发中，更多的应用场景是：
。使用 多个键值对，存储 描述一个 物体 的 相关信息——描述更复杂的数据信息
。将 多个字典 放在一个列表 中，再进行遍历，在循环体内部针对每一个字典进行 相同的处理

#  使用 多个键值对，存储 描述一个 物体 的 相关信息——描述更复杂的数据信息
#  将 多个字典 放在一个列表 中，再进行遍历，在循环体内部针对每一个字典进行 相同的处理
card_list = [
    {"name": "张三",
     "qq": 12345,
     "phone": 110},
    {"name": "李四",
     "qq": 54321,
     "phone": 10086
    }
]

for card_info in card_list:

    print(card_info)

四、字符串
· 字符串 就是 一串字符，是编程语言中表示文本的数据类型
· 在python中可以使用 一对双引号 或者 一对单引号 定义一个字符串
。实际开发中，大多数编程语言都是用“来定义字符串，如果字符串内部需要使用"，可以使用‘定义字符串
· 可以使用 索引 获取一个字符串中 指定位置的字符，索引计数从0开始
· 也可以使用for循环遍历 字符串中每一个字符

str1 = "hello python"
str2 = '我的外号是“椰子'

print(str2)
print(str1[2])

# 字符串的遍历
for c in str2:

    print(c)

1、字符串的常用操作
· len（字符串）——获取字符串的长度
· 字符串.count(字符串)——小字符串在大字符串中出现的次数
· 字符串[索引]——从字符串中取出单个字符
· 字符串.index（字符串）——获取小字符串第一次出现的索引

hello_str = "hello hello"

# 1、统计字符串长度
print(len(hello_str))

# 2、统计某一个小（子）字符串出现的次数
print(hello_str.count("llo"))
# 程序中没有的话不会报错
print(hello_str.count("abc"))

# 3、某一子字符串出现的位置
print(hello_str.index("llo"))
# 注意：如果使用index方法传递的子字符串不存在，程序会报错
# print(hello_str.index("abc"))

2、判断类型（9个）

· isspace（）也可以判断\t,\n,\r

# 1、判断空白字符
space_str = "    \t\n\r"

print(space_str.isspace())

# 2、判断字符串是否只包含数字
# 1>都不能判断小数
# num_str = "1.1"
# 2>nuicode 字符串
# num_str = "\u00b2"
# 3>中文数字
num_str = "椰子"

print(num_str)
print(num_str.isdecimal())
print(num_str.isdigit())
print(num_str.isnumeric())

3、查找和替换

hello_str = "hello world"

# 1、判断是否以指定字符串开始
print(hello_str.startswith("hello"))

# 2、判断是否以指定字符串结束
print(hello_str.endswith("world"))

# 3、查找指定字符串
# index方法同样可以查找指定的字符串在大字符串中的索引
print(hello_str.find("llo"))
# index 方法如果指定的字符串不存在，会报错
# find 如果指定的字符串不存在，会返回-1
print(hello_str.find("abc"))

# 4、替换字符串
# replace 方法执行完成后，会返回一个新的字符串
# 注意：不会修改原有字符串的内容
print(hello_str.replace("world", "python"))

print(hello_str)

4、文本对齐

# 要求：顺序并且居中对齐输出以下内容
poem = ["登鹳雀楼",
        "王之涣",
        "白日依山尽",
        "黄河入海流",
        "欲穷千里目",
        "更上一层楼"]

for poem_str in poem:

    # 居中对齐
    # print("|%s|" % poem_str.center(10, " "))
    # 相左对齐
    # print("|%s|" % poem_str.ljust(10, " "))
    # 向右对齐
    print("|%s|" % poem_str.rjust(10, " "))

5、去除空白字符

# 要求：顺序并且居中对齐输出以下内容
poem = ["\t\n登鹳雀楼",
        "王之涣",
        "白日依山尽\t\n",
        "黄河入海流",
        "欲穷千里目",
        "更上一层楼"]
        
    # 先使用strip方法去除字符串中的空白字符
    # 再使用center方法居中显示文本
    print("|%s|" % poem_str.strip().center(10, " "))

6、拆分和连接

7、字符串的切片
· 切片 方法适用于 字符串、列表、元组
。切片 使用 索引值 来限定范围，从一个大的 字符串 中 切出 小的 字符串
。列表 和 元组 都是 有序 的集合，都能够 通过索引值 获取到对应的数据
。字典 是一个 无序 的集合，是使用 键值对 保存数据

五、公共方法
列表、元组、字典、字符串都可以使用的方法。
1、python内置函数

· 注意：
。字符串 比较符合以下规则：“0” < “A” < “a”
。字典不能比较大小
。del两种用法：
a.关键字 del a[1]
b.函数 del(a[1])

2、切片

3、运算符

· 注意
。in 在对 字典 操作时，判断的是 字典的键
。in 和 not in 被称作 成员运算符
。extend 和 qppend 也可以进行拼接，不同的是不直接输出结果

t_list = [1,2]
t_list.extend([3,4])
print(t_list)

输出：[1,2,3,4]

t_list = [1,2,3,4]
t_list.append([8,9])
print(t_list)

输出：[1,2,3,4,[8,9]]

4、完整的for循环语法

for num in [1, 2, 3]:

    print(num)

    if num == 2:

        break

else:
    # 如果循环体内部使用break退出了循环
    # else下方的代码就不会被执行
    print("会执行吗？")

print("循环结束")

六、高级变量