Python初相识

数据容器的定义

• python中的数据容器定义：可以容纳多份数据的数据类型，其中每一份数据称为1个元素，元素类型可以是任意类型
• 数据容器根据是否支持重复元素、是否可以修改、是否有序等分为5类
• 分别为：列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)

列表的定义

• 基本语法：
• 以[]作为标识，列表内每个元素用逗号隔开
• [元素1,元素2,元素3] #字面量
• 变量名称 = [元素1,元素2,元素3] #定义变量
• 变量名称 = [] #定义空列表
• 变量名称 = list() #定义空列表
• # 列表可以一次存储多个数据，且数据类型不受限制，支持嵌套

列表特点

• 可以容纳多个元素
• 可以容纳不同类型的元素
• 数据是有序存储
• 允许重复数据存在
• 可以修改

列表方法的运用

# 定义一个列表
name_list = ['python1', 123, 'python2', [1, 2, 3]]
print(name_list)
print(type(name_list))
输出结果：
['python1', 123, 'python2', [1, 2, 3]]
<class 'list'>

# 通过下标索引取出元素,下标从左向右从0开始，从右向左从-1开始
print(name_list[0])
print(name_list[-4])
# 嵌套列表，夜支持下标索引
print(name_list[3][2])
输出结果：
python1
python1
3

# 列表常用方法
# 函数是一个封装的代码单元，而将函数定义为类的成员，这时函数就称为：方法

# 查找元素在列表内的下标索引
index = name_list.index(123)
print(f"123在列表中的下标索引值为:{index}")
输出结果：123在列表中的下标索引值为:1

# 修改特定下标的值
name_list[1] = 456
print(f"修改后{index}的值为:{name_list[1]}")
print(name_list)
输出结果：
修改后1的值为:456
['python1', 456, 'python2', [1, 2, 3]]

# 在指定位置插入新元素
# 语法：列表.insert(下标、元素)
name_list.insert(1, "best")
print(f"列表插入元素后，结果为：{name_list}")
输出结果：列表插入元素后，结果为：['python1', 'best', 456, 'python2', [1, 2, 3]]

# 在列表尾部追加一个元素
# 语法：列表.append(元素)
name_list.append("你好")
print(f"列表插入元素后，结果为：{name_list}")
输出结果：
列表插入元素后，结果为：['python1', 'best', 456, 'python2', [1, 2, 3], '你好']

# 追加多个元素
# 语法:列表.extend()
mylist = [1, 2, 3, 4, 5]
name_list.extend(mylist)
print(f"列表追加新的列表后，结果为：{name_list}")
输出结果：
列表追加新的列表后，结果为：['python1', 'best', 456, 'python2', [1, 2, 3], '你好', 1, 2, 3, 4, 5]

# 删除元素，方式1: del 列表[下标]
print(f"当前列表元素为：{name_list}")
# del name_list[0]
# print(f"删除第一个元素后结果为：{name_list}")
输出结果：
删除第一个元素后结果为：['best', 456, 'python2', [1, 2, 3], '你好', 1, 2, 3, 4, 5]

# 删除元素，方式2: 列表.pop(下标)
element = name_list.pop(0)
print(f"取出元素后列表结果为：{name_list},取出元素是：{element}")
输出结果：
取出元素后列表结果为：[456, 'python2', [1, 2, 3], '你好', 1, 2, 3, 4, 5],取出元素是：best

# 删除某个元素在列表中的第一个匹配项
mylist1 = ["python", 123, 456,"element",123]
print(f"当前mylist1列表中元素为：{mylist1}")
mylist1.remove(123)
print(f"通过remove1方法移除元素后，结果为：{mylist1}")
输出结果：
当前mylist1列表中元素为：['python', 123, 456, 'element', 123]
通过remove1方法移除元素后，结果为：['python', 456, 'element', 123]

# 清空列表
mylist1.clear()
print(f"清空mylist1列表后，结果是：{mylist1}")
输出结果：
清空mylist1列表后，结果是：[]

# 统计某个元素在列表中的数量
print(f"当前name_list列表中，元素有：{name_list}")
count = name_list.count(456)
print(f"列表中456的数量有{count}个")
输出结果：
当前name_list列表中，元素有：[456, 'python2', [1, 2, 3], '你好', 1, 2, 3, 4, 5]
列表中456的数量有1个

# 统计列表中，有多少元素
count = len(name_list)
print(f"当前name_list列表中，元素有：{name_list}")
print(f"name_list列表中元素的数量总共有{count}个")
输出结果：
当前name_list列表中，元素有：[456, 'python2', [1, 2, 3], '你好', 1, 2, 3, 4, 5]
name_list列表中元素的数量总共有9个

元组的定义

• 基本语法：
• 定义元组时使用小括号，使用逗号隔开各个数据，数据可以时不同数据类型
• # 定义元组字面量
• (元素,元素,元素)

定义元组变量

• 变量名称 = (元素,元素,元素)
• # 定义空元组
• 变量名称 = () #方式一
• 变量名称 = tuple() #方式二

元组的操作方法

• index(),查找某个数据，如果数据存在返回对应的下标，否则报错
• count(),统计某个数据在当前元组出现的次数
• len(),统计元组内的元素个数

元组的特点

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 数据是有序存储的(下标索引)
• 允许重复数据存在
• 不可以修改元素
• 支持for循环

元组方法的运用

# 定义元组
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}")
输出结果：
t1的类型是：<class 'tuple'>，内容是：(1, 'hello', True)
t2的类型是：<class 'tuple'>，内容是：()
t3的类型是：<class 'tuple'>，内容是：()

# 定义单个元素的元组时，后面要加逗号
t4 = ("hello")
t5 = ("hello",)
print(f"t4的类型是：{type(t4)}，内容是：{t4}")
print(f"t5的类型是：{type(t5)}，内容是：{t5}")
输出结果：
t4的类型是：<class 'str'>，内容是：hello
t5的类型是：<class 'tuple'>，内容是：('hello',)

# 元组的嵌套
t6 = ((1,2,3),(4,5,6))
print(f"t6的类型是：{type(t6)}，内容是：{t6}")
输出结果：
t6的类型是：<class 'tuple'>，内容是：((1, 2, 3), (4, 5, 6))

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

# 元组的操作：index查找方法
t7 = ("你好python",123,"hello")
index = t7.index("你好python")
print(f"在元组t7中查找你好python的下标是：{index}")
输出结果：
在元组t7中查找你好python的下标是：0

# 元组的操作：count统计方法
t8 = ("你好世界","程序员","python","hello","hello")
num = t8.count("hello")
print(f"t8中hello的个数有：{num}个")
输出结果：
t8中hello的个数有：2个

# 元组的操作：len函数统计元组的元素数量
t9 = ("你好世界","程序员","python","hello","hello")
num = len(t9)
print(f"t9元组中元素的个数有：{num}个")
输出结果：
t9元组中元素的个数有：5个

# 元组的遍历：while
index = 0
while index < len(t9):
    print(f"t9元组中的元素有：{t9[index]}")
    index += 1
print("------------分割线------------")
输出结果：
t9元组中的元素有：你好世界
t9元组中的元素有：程序员
t9元组中的元素有：python
t9元组中的元素有：hello
t9元组中的元素有：hello

# 元组的遍历：for
for element in t8:
    print(f"t8元组的元素有：{element}")
输出结果：
t8元组的元素有：你好世界
t8元组的元素有：程序员
t8元组的元素有：python
t8元组的元素有：hello
t8元组的元素有：hello

字符串的定义

• 基本语法：
• 定义字符串时使用双引号
• # 定义字符串
• "元素"

字符串的特点：

• 只可以存储字符串
• 长度任意(取决于内存大小)
• 支持下标索引
• 允许重复字符串存在
• 不可以修改
• 支持for循环

字符串方法的运用

my_str = "hello world"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-8]
print(f"从字符串{my_str}取下标为2的元素，值为：{value}")
print(f"从字符串{my_str}取下标为-8的元素，值为：{value}")
输出结果：
从字符串hello world取下标为2的元素，值为：l
从字符串hello world取下标为-8的元素，值为：l

# index方法
value = my_str.index("world")
print(f"字符串{my_str}中查找world，其起始位置是：{value}")
输出结果：
字符串hello world中查找world，其起始位置是：6

# replace方法
# 字符串的替换
# 功能：将字符串内的全部字符串1，替换为字符串2
# 注意：不是修改字符串本身，而是得到一个新的字符串
new_my_str = my_str.replace("hello","nihao")
print(f"将字符串{my_str}进行替换后得到的字符串是：{new_my_str}")
输出结果：
将字符串hello world进行替换后得到的字符串是：nihao world

# split方法
# 字符串的分割
# 功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
# 注意：字符串本身不变，而是得到一个新的列表对象
my_str = "hello nihao world python"
my_str_list = my_str.split(" ")
print(f"将字符串my_str按空格进行切分后得到：{my_str_list},类型是：{type(my_str_list)}")
输出结果：
将字符串my_str按空格进行切分后得到：['hello', 'nihao', 'world', 'python'],类型是：<class 'list'>

# strip方法
# 字符串的规整操作(默认去除前后空格)
# 传入字符串后，去除前后字符串
my_str = " hello world "
new_my_str = my_str.strip()
print(f"字符串{my_str}被strip后，结果为：{new_my_str}")
输出结果：
字符串 hello world 被strip后，结果为：hello world

my_str = "12hello world21"
new_my_str = my_str.strip("12")
print(f"字符串{my_str}被strip('12')后，结果为：{new_my_str}")
输出结果：
字符串12hello world21被strip('12')后，结果为：hello world

# 统计字符串中某个字符串出现的次数
my_str = "hh,long time long see"
num = my_str.count("hh")
print(f"字符串('hh')在{my_str}中出现了{num}次")
输出结果：
字符串('hh')在hh,long time long see中出现了1次

# 统计字符串的长度
num = len(my_str)
print(f"字符串{my_str}的长度是{num}")
输出结果：
字符串hh,long time long see的长度是21

集合的定义

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

集合的特点

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 数据是无序存储的，不支持下标索引
• 不允许重复数据存在
• 可以修改元素
• 不支持while循环

集合方法的运用

# 定义集合
my_set = {"你好世界", "python", 123456, "python", "你好世界", "hello"}
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的内容是：{123456, '你好世界', 'python', 'hello'},类型是：<class 'set'>
my_set_empty的内容是：set(),类型是：<class 'set'>

# 添加新元素
my_set.add("hello world")
print(f"my_set的内容是：{my_set}")
输出结果：my_set的内容是：{123456, 'hello', '你好世界', 'python', 'hello world'}

# 移除元素
my_set.remove("python")
print(f"移除元素后，my_set的内容是：{my_set}")
输出结果：
移除元素后，my_set的内容是：{123456, 'hello', '你好世界', 'hello world'}

# 随机取出一个元素
print(f"当前my_set内容是：{my_set}")
element = my_set.pop()
print(f"集合被取出元素为：{element},取出元素后内容是：{my_set}")
输出结果：
当前my_set内容是：{123456, 'hello', '你好世界', 'hello world'}
集合被取出元素为：123456,取出元素后内容是：{'hello', '你好世界', 'hello world'}

# 清空集合
my_set.clear()
print(f"集合被清空后，结果为：{my_set}")
输出结果：集合被清空后，结果为：set()

# 取两个集合的差集,取出元素是集合1有，而集合2没有的元素
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(set1)
print(set2)
print(set3)
输出结果：
{1, 2, 3}
{1, 5, 6}
{2, 3}

# 消除2个集合的差集
# 删除集合内和集合2相同的元素
# 结果：集合1被修改，集合2不变
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果：{set1}")
print(f"消除差集后，集合2结果：{set2}")
输出结果：
消除差集后，集合1结果：{2, 3}
消除差集后，集合2结果：{1, 5, 6}

# 集合合并,不修改集合本身，得到一个新的集合
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果：{set3}")
输出结果：
2集合合并结果：{1, 2, 3, 5, 6}

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

# 集合的遍历
set1 = {1, 2, 3, 4, 5}
for element in set1:
    print(f"set1集合内的元素有：{element}")
输出结果：
set1集合内的元素有：1
set1集合内的元素有：2
set1集合内的元素有：3
set1集合内的元素有：4
set1集合内的元素有：5

# 例子
# 定义一个列表
my_list = ["你好世界","hello world","python","数据","data","data"]

# 定义一个空集合
my_set_empty = set()

# 通过循环将元素加入集合，去重操作
for element in my_list:
    my_set_empty.add(element)

print(f"my_set_empty集合内元素是：{my_set_empty}")
输出结果：
my_set_empty集合内元素是：{'数据', '你好世界', 'python', 'hello world', 'data'}

字典的定义

• # 定义字典字面量
• {key:value,key:value,...key:value}
• # 定义字典变量
• my_dict = {key:value,key:value,...key:value}
• # 定义空字典
• my_dict = {} 方式1
• my_dict = dict() 方式2

注意事项

• 键值对的key和value可以是认识类型
• 字典内key不可以重复，重复添加等同于覆盖原有数据
• 字典不可以使用向下索引，，通过key取寻找value值

字典的特点

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是key-value键值对
• 可以通过key获取到value，key不可重复(重复会覆盖)
• 不支持下标索引
• 可以修改(增加或删除元素)
• 支持for循环，不支持while循环(不支持下标索引)

字典方法的运用

# 定义嵌套字典
stu_score_dict = {
    "张三": {
        "语文": 77,
        "数学": 88,
        "英语": 80
    }, "李四": {
        "语文": 79,
        "数学": 80,
        "英语": 88
    }, "王五": {
        "语文": 89,
        "数学": 79,
        "英语": 83
    }
}
score = stu_score_dict["张三"]["语文"]
print(f"张三的语文成绩是：{score}")
输出结果：张三的语文成绩是：77

# 常用操作
my_dict = {"张三": 88, "李四": 77, "王五": 66}
# 新增元素
# 语法：字典[key] = value,key值不存在，即新增元素
my_dict["赵六"] = 68
print(f"新增元素后，结果为：{my_dict}")
输出结果：
新增元素后，结果为：{'张三': 88, '李四': 77, '王五': 66, '赵六': 68}

# 更新元素
# 语法：字典[key] = value，key值存在，即更新元素
my_dict["赵六"] = 70
print(f"更新元素后，结果为：{my_dict}")
输出结果：
更新元素后，结果为：{'张三': 88, '李四': 77, '王五': 66, '赵六': 70}

# 删除元素
# 语法：字典.pop(key),结果指定key的value，同时字典被修改，指定key的数据被删除
# 即取出key对应的value并在字典中删除此key的键值对
score = my_dict.pop("张三")
print(f"移除元素后，结果为：{my_dict},移除元素值为:{score}")
输出结果：
移除元素后，结果为：{'李四': 77, '王五': 66, '赵六': 70},移除元素值为:88

# 清空元素，clear()
# my_dict.clear()
# print(f"清空字典后，结果为：{my_dict}")

# 获取全部的key
# 语法：字典.keys(),结果：得到字典中的全部key
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")
输出结果：字典的全部keys是：dict_keys(['李四', '王五', '赵六'])

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

# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(f"字典2的key是：{key}")
    print(f"{key}对应的value值是：{my_dict[key]}")
输出结果：
字典2的key是：李四
李四对应的value值是：77
字典2的key是：王五
王五对应的value值是：66
字典2的key是：赵六
赵六对应的value值是：70

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

# 小练习
"""
使用字典完成数据的记录，并让所有级别1的员工，级别上升1级，薪水增加1k
姓名      部门      工资          级别
张三      科技部     10000       1
李四      市场部     11000       2
王五      科技部     9000        3
赵六      科技部     10000        1
"""
info_dict = {
    "张三": {
        "部门": "科技部",
        "工资": 10000,
        "级别": 1
    },
    "李四": {
        "部门": "市场部",
        "工资": 11000,
        "级别": 2
    },
    "王五": {
        "部门": "科技部",
        "工资": 9000,
        "级别": 3
    },
    "赵六": {
        "部门": "科技部",
        "工资": 10000,
        "级别": 1
    }
}
print(f"员工在升职加薪前的结果为：{info_dict}")
输出结果：
员工在升职加薪前的结果为：
{'张三': {'部门': '科技部', '工资': 10000, '级别': 1}, 
  '李四': {'部门': '市场部', '工资': 11000, '级别': 2}, 
 '王五': {'部门': '科技部', '工资': 9000, '级别': 3}, 
 '赵六': {'部门': '科技部', '工资': 10000, '级别': 1}}
for name in info_dict:
    if info_dict[name]["级别"] == 1:
        # 获取员工信息
        employee_info_dict = info_dict[name]
        # 修改员工信息
        employee_info_dict["级别"] += 1
        employee_info_dict["工资"] += 1000
        # 更新员工信息
        info_dict[name] = employee_info_dict

print(f"员工在升职加薪后的结果为：{info_dict}")
输出结果：
员工在升职加薪后的结果为：
{'张三': {'部门': '科技部', '工资': 11000, '级别': 2}, 
 '李四': {'部门': '市场部', '工资': 11000, '级别': 2}, 
 '王五': {'部门': '科技部', '工资': 9000, '级别': 3}, 
 '赵六': {'部门': '科技部', '工资': 11000, '级别': 2}}