作业回顾

homework01

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

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

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

# 从列表中删除第一次出现的数据，如果数据不存在，程序会报错
name_list.remove("张三")

homework02

name_list = ["zhangsan", "lisi", "wangwu", "wangxiaoer"]
num_list = [6, 8, 4, 1, 10]

# 升序
name_list.sort()    # 按首字母排序
num_list.sort()     # 从小到大
# 降序
name_list.sort(reverse=True)
num_list.sort(reverse=True)

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

for item in name_list:
    print(item)

for i in num_list:
    print(i)

一、综合练习(列表外传)

1、案例需求

• list01 = [1,2,3,4,5,6,7,8,9,10] 删除列表中所有奇数
• 要求倒序删除

非常重要!!!

先举个栗子：实现列表正向删除操作

list01 = [1, 2, 3, 4, 5, 6, 7, 8]
# 列表正向的弊端
# 首先判断1<5,将1删除，之后列表变成[2,3,4,5,6,7,8]，即且数据整体向前迁移一位
# 第二步判断的不是2，而是3，3< 5将3删除，之后列表变成[2,4,5,6,7,8]
# 第三步判断的不是4，而是5，5=5，不删除，输出5
for i in list01:
    if i<4:
        list01.remove(i)
print(list01)

原始列表

list01	1	2	3	4	5	6	7	8
索引	0	1	2	3	4	5	6	7

首先判断1<5,将1删除，之后列表变成[2,3,4,5,6,7,8]，即且数据整体向前迁移一位

list01	2	3	4	5	6	7	8
索引	0	1	2	3	4	5	6

第二步判断的不是2，而是3，3< 5将3删除，之后列表变成[2,4,5,6,7,8]

list01	2	4	5	6	7	8
索引	0	1	2	3	4	5

第三步判断的不是4，而是5，5=5，不删除，输出5

断点操作教学

以上要细品、一定要细品！！

既然正向不行了，那我们就倒叙删除吧

list01 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 删除元素方法有两种：
# 1、用倒序的方法删除，防止值自动补位
for i in range(len(list01)-1,-1,-1):
    if list01[i]%2:
        # 删除语法一：
        # list01.pop(i)
        # 删除语法二：
        del list01[i]
print(list01)

# 2、正向通过索引删除值（enumerate比较高级暂时未学到此知识点【慎用】）
for index,value in enumerate(list01):
    if list01[index]%2:
        # 删除语法一：
        list01.pop(index)
        # 删除语法二：
        # del list01[index]
        # 删除语法三：
        # list01.remove(value)
print(list01)

2、案例需求

• 求斐波那契数列：输入长度求具体数列
• 从第三项开始，每一项都等于前两项之和
• 1,1,2,3,5,8,…

lenght = int(input("请输入斐波那契数列长度："))
# 如长度为6
fib= [1,1]
for __ in range(lenght - 2):
# 当前元素 = 最后两个元素之和
    element = fib[-2] + fib[-1]
    fib.append(element)
print(fib)

3、案例需求

• list01 = [2, 9, 40, 16, 57, 38]
• 求列表最大值
• 思路：从首位开始对比后一位，如果满足则替换，直至对比到最后

list01 = [2, 9, 40, 16, 57, 38]
max_value = list01[0]
for i in range(1, len(list01)):
    if max_value < list01[i]:
       max_value = list01[i]
print("最大值：",max_value)

4、列表深拷贝与浅拷贝

浅拷贝：是在复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。

深拷贝：复制整个依懒的变量。

二、元组

1、元组的定义

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

info_tuple = ("zhangsan", 18, 1.75)

① 创建空元组

info_tuple = ()

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

info_tuple = (50, )

2、元组常用操作

• 在ipython3中定义一个元组，例如：message = ()
• 输入message .按下TAB键，ipython会提示元组能够使用的函数如下：

info.count  info.index

有关元组的常用操作可以参照上图练习

3、 循环遍历

• 取值就是从元组中获取存储在指定位置的数据
• 遍历就是从头到尾依次从元组中获取数据

# for 循环内部使用的变量 in 元组
for item in info:

    循环内部针对元组元素进行操作
    print(item)

案例演示

# 通过索引
t03=(1,2,3,4)
正向
for index in range(len(t03)):
    print(t03[index],end="")    #1234
print("")
反向
for index in range(len(t03)-1,-1,-1):
    print(t03[index],end="")    #4321

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

4、 应用场景

• 尽管可以使用for in遍历元组
• 但是在开发中，更多的应用场景是：
  • 函数的 参数 和 返回值，一个函数可以接收任意多个参数，或者一次返回多个数据
    • 有关函数的参数 和 返回值，在后续函数高级给大家介绍
  • 格式字符串，格式化字符串后面的()本质上就是一个元组
  • 让列表不可以被修改，以保护数据安全

info = ("zhangsan", 18)

print("%s 的年龄是 %d" % info)

5、元组和列表之间的转换

• 使用list函数可以把元组转换成列表

list(元组) 

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

tuple(列表)

案例演示

list01 = [25, 89, 32, 15, 23, 66]
tuple01 = (25, 89, 32, 15, 23, 66)
print("元组转列表",list(tuple01))
print("列表转元组",tuple(list01))

输出显示

6、元组与列表（区分）

元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。

元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。

列表（可变）：预留空间

元组（只读）：按需分配

三、字典

1、字典的定义

• dictionary（字典） 是除列表以外Python之中最灵活的数据类型
• 字典同样可以用来存储多个数据
  • 通常用于存储描述一个物体的相关信息
• 和列表的区别
  • 列表是有序的对象集合
  • 字典是无序的对象集合
• 字典用{}定义
• 字典使用键值对存储数据，键值对之间使用,分隔
  • 键key是索引
  • 值value是数据
  • 键和值之间使用:分隔
  • 键必须是唯一的（键不能相同，值可以相同）
  • 值可以取任何数据类型，但键只能使用字符串、数字或元组

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

2、 字典常用操作

• 在ipython3中定义一个字典，例如：xiaoming = {}
• 输入xiaoming.按下TAB键，ipython会提示字典能够使用的函数如下：

In [1]: xiaoming.
xiaoming.clear       xiaoming.items       xiaoming.setdefault
xiaoming.copy        xiaoming.keys        xiaoming.update
xiaoming.fromkeys    xiaoming.pop         xiaoming.values
xiaoming.get         xiaoming.popitem    

有关字典的常用操作可以参照上图练习

案例演示

dict01 = {1001:"王宝强",1002:"马蓉",1005:"宋喆"}
# 1. 添加
# --通过键-值
dict01[1003] = "文章"

# 2. 修改（如果key存在,则为修改,不存在则为添加）
dict01[1002] = "伊利"

# 3. 删除
# 如果key不存在则报错
if 1001 in dict01:
    del dict01[1001]

# 4. 查询
# key/循环
print(dict01[1005])

3、 循环遍历

• 遍历就是依次从字典中获取所有键值对

# for 循环内部使用的 `key 的变量` in 字典
for k in xiaoming:

    print("%s: %s" % (k, xiaoming[k]))

提示：在实际开发中，由于字典中每一个键值对保存数据的类型是不同的，所以针对字典的循环遍历需求并不是很多

案例演示

dict01 = {1001:"王宝强",1002:"马蓉",1005:"宋喆"}
# -- 获取所有key 	# 1001 1002 1005
for key in dict01:
    print(key)

# --获取所有value	# 王宝强 马蓉 宋喆
for value in dict01.values():
    print(value)

# --获取所有key - value 	#	1001 王宝强 1002 马蓉 1005 宋喆
for key,value in dict01.items():
    print(key)
    print(value)
    

4 、应用场景

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

card_list = [{"name": "张三",
              "qq": "12345",
              "phone": "110"},
             {"name": "李四",
              "qq": "54321",
              "phone": "10086"}
             ]

5、列表与字典转换

• 列表(格式) --> 字典
• 格式：[(k,v),(k,v)]
• 字典 --> 列表(只保留key)

案例演示

stu01 = {1001:"王宝强",1002:"马蓉",1005:"宋喆"}
stu02 = dict(["宝强",(125,"马小荣"),[234,"宋喆"]])
list01 = list(stu01)
print(stu02)
print(list01)

输出显示

6、字典与列表（区分）

• 都是可变容器。
• 获取元素方式不同,列表用索引,字典用键。
• 字典的插入,删除,修改的速度快于列表。
• 列表的存储是有序的,字典的存储是无序的。

四、集合（set）

1、定义

• 由一系列不重复的不可变类型变量组成的可变散列容器。
• 相当于只有键没有值的字典(键则是集合的数据)。

2、基础操作

① 创建空集合：

集合名 = set()

集合名 = set(可迭代对象)

② 创建具有默认值集合：

集合名 = {1, 2, 3}

集合名 = set(可迭代对象)

添加元素：集合名.add(元素)

update()方法用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

案例演示

set2={"a", 2, "b", 3, "d"}
set1 = {"a", 2, "b", 3, "e"}
set2.update(set1)
print(set2)#{2, 3, 'd', 'b', 'a', 'e'}

③ 删除元素：

• 集合名.discard(元素)
• 集合名.remove(元素)

④ 随机移除元素

• 集合名.pop()

⑤ 移除集合中的所有元素：

• 集合名.clear()#清除

⑥ 拷贝一个集合:copy()

• 集合名.copy()

3、运算

1 交集&：返回共同元素。

s1 = {1, 2, 3}

s2 = {2, 3, 4}

s3 = s1 & s2  # {2, 3}

2 并集 |：返回不重复元素

s1 = {1, 2, 3}

s2 = {2, 3, 4}

s3 = s1 | s2  # {1, 2, 3, 4}

3 补集-：返回只属于其中之一的元素

 s1 = {1, 2, 3}

 s2 = {2, 3, 4}

 s1 - s2  # {1} 属于s1但不属于s2

 s2 - s1  # {4} 属于s2但不属于s1

4 补集^：返回不同的的元素

s1 = {1, 2, 3}

  s2 = {2, 3, 4}

  s3 = s1 ^ s2  # {1, 4}  等同于(s1-s2 | s2-s1)

子集<：判断一个集合的所有元素是否完全在另一个集合中

超集>：判断一个集合是否具有另一个集合的所有元素

s1 = {1, 2, 3}

s2 = {2, 3}

s2 < s1  # True

s1 > s2  # True

相同或不同== !=：判断集合中的所有元素是否和另一个集合相同。

s1 = {1, 2, 3}

s2 = {3, 2, 1}

s1 == s2  # True

s1 != s2  # False

子集或相同,超集或相同 <= >=

4、集合推导式

定义：使用简易方法，将可迭代对象转换为集合。

语法:

{表达式 for 变量 in 可迭代对象}

{表达式 for 变量 in 可迭代对象 if 条件}

固定集合 frozenset

定义：不可变的集合。

作用：固定集合可以作为字典的键,还可以作为集合的值。

基础操作：创建固定集合：frozenset(可迭代对象)

运算：等同于set