python第二天

列表（List)

列表是一个有序的可变集合，可以存储不同类型的元素。列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据。而且列表是有序的，有索引值，可切片，方便取值。

###  定义列表

fruits = ["apple", "banana", "cherry"]
print(fruits)

# Output:
['apple', 'banana', 'cherry']

增加元素

# 1. 按照索引的位置去增加
fruits.insert(1, "kiwi")

# 2. 在最末尾添加
fruits.append("orange")

# 3. 用迭代的方式去添加
fruits.extend(['a','b','c'])        
# 可以添加列表、字典等，把其中的元素依次添加到末尾,而append会把括号当成一个整体添加到末尾

# Output:
['apple', 'kiwi', 'banana', 'cherry', 'orange', 'a', 'b', 'c']

删除元素

# 1. 按照索引位置去删除
fruits.pop()        # 默认是删除最后一个，可以加上索引。并且有返回值，返回值为删除的元素
fruits.pop(1)

想得到返回值：poped_fruits=fruits.pop(1)    可以pop(index)得到任意单元素变量


 # 2. 清空列表
fruits.clear()

# output: []

修改元素

# 1. 按照索引位置 ，修改某个元素的值
fruits = ["apple", "banana", "cherry"]
fruits[1] = "orange"
print(fruits)

# Output:
['apple', 'orange', 'cherry']

# 2. 按照切片范围修改
fruits[0:2] = ['kiwi','orange']
print(fruits)

# Output:
['kiwi', 'orange', 'cherry']

查找元素

# 1. 用变量名.index("元素名") ，返回元素的索引
fruits = ["apple", "banana", "cherry"]
index_of_apple = fruits.index("apple")
print(index_of_apple)

# Output:
0

# 2. 用变量名.count("元素名")方法,返回元素出现的次数
count_of_cherry = fruits.count("cherry")
print(count_of_cherry)

# Output:
1

列表的切片

切片:切出==新的列表== ，按照索引位置切片

li = [1,2,4,5,4,2,4]
sub_li = li[2:5]
print(sub_li)

# Output:
[4, 5, 4]

排序和反序方法

# 1. 对列表进行排序
li.sort( )
print(li)

# 按照首字母顺序和数字大小排列

#2. 将列表中的元素反向存放
li.reverse()
print (li)

# Output:

[1, 2, 2, 4, 4, 4, 5]
[5, 4, 4, 4, 2, 2, 1]

元组（Tuple）

有序的==不可变集合==, 即==只读列表==，里面==数据不可被修改==

定义元组

tuple = (1,2,3,'a','b','c')
print(tuple)
print(tuple[1])

# 可以删除元素吗?
tuple.pop()

# 报错里面的元素不可-增或删-,pop()方法用不了

可变元组

tuple 其实==不可变的是地址空间==，如果地址空间里存的是List,Dict，那么==列表或字典里的元素可增改==，列表或字典不可删除

tuple = (1, 2, 3, [1, 4, 7])
print(tuple)
tuple[3][2] = 100
print(tuple)

# Output:
(1, 2, 3, [1, 4, 7])
(1, 2, 3, [1, 4, 100])

字典`（Dict）`

字典是 python 中唯一的==映射==类型，采用键值对（key-value）的形式存储数据。python 对 key 进行哈希函数运算，根据计算的结果决定 value 的存储地址，所以字典是==无序存储==的，且key必须是可哈希的。可哈希表示==key== 必须是不可变类型，如：==数字、字符串、元组==。

不过在 Python 3.6 版本以后，字典会保留插入顺序，变成有序数据结构。

而且键是具有唯一性的，==每个键只能出现一次==，但是值没有限制，在一个字典中可以出现多个相同的值

定义字典

dic = {'name':'nls','age':18,'job':'teacher'}
print(dic)
print(dic['name'])
print(dic['age'])
print(dic['job'])

# Output:
{'name': 'nls', 'age': 18, 'job': 'teacher'}
nls
18
teacher

==注意==：键不可变且只出现一次不能有相同的key，但value不唯一

dic = {'name':'nls','age':18,'job':'teacher'}

# 1. 直接通过键值对来增加
dic['hobby'] = 'study'        # 如果键已经存在，那么就会替换原来的值

print(dic)

# Output: {'name': 'nls', 'age': 18, 'job': 'teacher', 'hobby': 'study'}

删除键值

dic = {'name':'nls','age':18,'job':'teacher'}

# 1. 删除指定的键,并且返回对应的值
name = dic.pop('job')
hobby = dic.pop('hobby','None')        # 可以在后面加上一个异常处理，如果key不存在，就输出后面的内容
print(dic)
print(name)
print(hobby)

# Output:
{'name': 'nls', 'age': 18}
teacher
None

# 2. 删除最后插入的键值对
dic_pop = dic.popitem()
print(dic_pop)

#返回一个元组：('job','teacher')


# 3. 清空字典
dic.clear()
print(dic)

# Output: {}

修改键值

dic = {'name':'nls','age':18,'job':'teacher'}
dic['age'] = 25

print(dic)

# Output:
{'name': 'nls', 'age': 25, 'job': 'teacher'}

查找键值

dic = {'name':'nls','age':18,'job':'teacher'}
# 1. 直接通过键名获取，如果不存在会报错
value = dic['name']
print(value)


# 2. IN关键字，存在返回True，反之False
exists = "name" in dic
print(exists)

# Output:
True

其他操作

dic = {'name':'nls','age':18,"phone":['1888888888','0511-10101010']}
# 字典里面的value也可以是容器类型的数据，比如列表，字典等等...但是key必须是不可变的
print(dic)

# 1. 对键和值进行迭代操作
for i in dic.items():
    # 将键和值作为元组列出
    print(i)


# Output:
('name', 'nls')
('age', 18)
('phone', ['1888888888', '0511-10101010'])


# 2. 使用keys()和values()方法获取键值
keys = dic.keys()
print(keys)            # dict_keys(['name', 'age', 'phone']) 
value = dic.values()
print(value)          # dict_values(['nls', 18, ['1888888888', '0511-10101010']])

# 想将其转化为列表
key_list=list(keys)
val_list=list(value)

# ['name','age','phone']
# ['nls',18,['1888888888','0511-10101010']]

==注意==:直接取键或值的列表print( list( dict.keys( ) ) )

print( list( dict.values( ) ) )

['name','age','phone']
['nls',18,['1888888888','0511-10101010']]

集合(Set):无序，去重，{ }

集合是无序的，不重复，确定性的数据集合，它里面的==元素是不可变==，但是集合本身是可变的（所以集合做不了字典的键）。以下是集合最重要的两点：

==去重==，把一个列表变成集合，就==自动去重==了。set( ) 括号里放List,Dict,Tuple,Str,
关系测试，测试两组数据之前的交集、差集、并集等关系。

add 增加元素

set1 = {1,2,3,'a','b','c'}
# 1. 使用add()方法为集合增加元素,因为无序所以set没有append( )方法
set1.add('Apple')
print(set1)

# Output:
{'a', 1, 2, 3, 'c', 'Apple', 'b'}

# 2. 使用update()方法迭代的去增加
set1.update('Helloworld')
# update接收的参数应该是可迭代的数据类型，比如字符串、元组、列表、集合、字典。这些都可以向集合中添加元素，但是整型、浮点型不可以
set1.update([4,5,6])
print(set1)

# Output:
{1, 2, 3, 4, 5, 6,'a','b','c','H','e','l','o','w','r','d'}

==注意==：[4,5,6]里面元素是一个一个加进去的

'Helloworld'这个字符串里的单个字符是一个一个加进去的，并且去重了，集合是不重复的

remove 删除元素

set1 = {1,2,3,'a','b','c'}
# 1. 使用remove()方法删除元素，因为无序所以不能pop(index)按索引删除元素
set1.remove('a')

print(set1)

# Output:
{1, 2, 3, 'c', 'b'}

关系测试

交集

取出两个集合共有的元素

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}

print(set1 & set2)     #  &=and

# Output:
{3, 4, 5}

反交集:交集的补集

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}

print(set1 ^ set2)    # 全集-交集

# Output:
{1, 2, 6, 7}

并集

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}

print(set1 | set2)  #  | = set1 + set2

# Output:
{1, 2, 3, 4, 5, 6, 7}

差集

第一个集合去除二个集合的共同元素

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}

print(set1 - set2)

# Output:
{1, 2}

子集与超集

当一个集合的所有元素都在另一个集合里，则称这个集合是另一个集合的子集，另一个集合是这个集合的超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)  #  set1 是子集， set2是超集


print(set2 > set1)

`frozenset`不可变集合

set1 = {1,2,3,4,5,6}

set2 = frozenset(set1)
print(set2)

set2.add(7) # 不可以修改,会报错，frozenset冻结了集合

# Output:
# 报错

==数据结构总结==

数据结构	字符串`str` ” “	列表list [ ]	元组 ( )	字典`Dict{ }`	集合 Set { }
描述	字符的序列	有序的，可变 [ ]	有序的，不可变，( )	无序的,键值对,{ }	无序的，可变集合set( )
特性	不可变	可变，支持重复	不可变，支持重复	可变，键唯一	无序，可变，==不支持重复==

数据结构是计算机存储、组织数据的方式。选择合适的数据结构，可以显著提升算法的效率。简单来说，它定义了数据如何存放以及数据之间有何关系。

一：为什么要学习数据结构？它的核心价值在于权衡与优化。同一个问题可以用不同数据结构解决，但效率天差地别。

提高效率：良好的数据结构能显著提升算法的时间（如查找、排序）和空间效率。例如，在100万条记录中查找一个用户，哈希表（O(1)）比数组遍历（O(n)）快数十万倍。

组织复杂数据：现实世界的数据关系复杂（如组织架构、社交网络），需要树、图等结构来建模。

支持特定操作：有些问题需要特殊的存取方式，比如撤销操作天然适合“后进先出”的栈结构。

二：如何选择合适的数据结构？没有完美的数据结构，只有最合适的。选择时主要考虑以下三点：

核心操作：你的程序主要进行查找、插入、删除还是排序？

数据量级：数据是固定的几十个，还是百万级动态增长？

数据关系：数据间是一对一的线性关系，还是一对多的层次、多对多的网状关系？

一个经典的选择场景：实现一个网页的“最近浏览记录”功能，要求快速访问最近5条记录，且新记录要淘汰最旧的。这个需求恰好符合队列的先进先出特性，并用固定大小的数组实现即可。

流程控制

判断语句

语法：

if 条件:
    满足条件后要执行的代码

==注意==：只有条件== ==True==时才可执行 if 板块体内缩进代码

多分支判断

if 条件:
    满足条件执行代码
elif 条件:
    上面的条件不满足就走这个
elif 条件:
    上面的条件不满足就走这个
elif 条件:
    上面的条件不满足就走这个    
else:
    上面所有的条件不满足就走这段


# 成绩判断程序
# 提示用户输入成绩
score = int(input("请输入成绩（0-100）："))

# 多分支判断成绩
if score >= 90 and score <= 100:
    print("优秀")
elif score >= 60 and score < 90:
    print("良好")
elif score >= 0 and score < 60:
    print("不及格")
else:
    print("输入错误，请输入0到100之间的成绩。")

==注意==：只有一个分支会运行

循环语句 – while

语法：

while 条件:
     循环体

# 循环条件可以直接是True/False或者1/0，也可以是某个语句...

如果条件为真，那么循环体则执行；如果条件为假，那么循环体不执行

示例：猜数字小游戏

print('猜数字游戏开始')
num = 54
while True:
    guess = int(input("您猜数字是什么？(输入0-100的数字):"))
    if guess < num:
        print("您猜小了")
        continue
    elif guess > num:
        print("您猜大了")
        continue
    break

print("您猜对了！")

# Output:
猜数字游戏开始
您猜数字是什么？(输入0-100的数字):10
您猜小了
您猜数字是什么？(输入0-100的数字):50
您猜小了
您猜数字是什么？(输入0-100的数字):60
您猜大了
您猜数字是什么？(输入0-100的数字):54
您猜对了！

==注意==: continue 会跳过单分支条件判断，break会跳出循环体while终止循环

循环终止语句

break

用于完全结束一个循环，跳出循环体执行循环后面的语句

continue

和 break 有点类似，区别在于 continue 只是终止本次循环，接着还执行后面的循环，break 则完全终止循环

while …… else

while 后面的 else 作用是指，当 while 循环正常执行完，中间没有被 break 中止的话，就会执行 else 后面的语句

语法：

while condition:
    # 循环体
    if some_condition:
        break
else:
    # 循环正常结束时执行的代码

循环语句for

for 循环：用户按照顺序循环可迭代对象的内容

语法：

for variable in iterable:
    # 循环体
    # 执行的代码

遍历列表

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# Output:
apple
banana
cherry

遍历字符串

word = "helloworld"
for letter in word:
    print(letter)

# Output:
h
e
l
l
o
w
o
r
l
d

enumerate

enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate 将其组成一个索引序列，利用它可以同时获得==索引==和==值==。

li = ['甲','乙','丙','丁']
for i in enumerate(li):
    print(i)

for index,value in enumerate(li):
    print(index,value)

for index,value in enumerate(li,100):      #  从哪个数字开始索引
    print(index,value)

# Output:
(0, '甲')
(1, '乙')
(2, '丙')
(3, '丁')
0 甲
1 乙
2 丙
3 丁
100 甲
101 乙
102 丙
103 丁

range

指定范围，生成指定数字

for i in range(1,10):
    print(i)

for i in range(1,10,2):  # 步长，取奇数
    print(i)

小游戏案例

import random
# random产生随机值或者从给定值中随机选择

# 可选择的选项
options = ["石头", "剪子", "布"]

print("欢迎来到石头剪子布游戏！")
print("请从以下选项中选择：")
for i, option in enumerate(options):
    print(f"{i + 1}. {option}")

# 玩家选择
player_choice = int(input("请输入你的选择（1-3）：")) - 1

# 计算机随机选择
computer_choice = random.randint(0, 2)

print(f"n你选择了：{options[player_choice]}")
print(f"计算机选择了：{options[computer_choice]}")

# 判断胜负
if player_choice == computer_choice:
    print("平局！")
elif (player_choice == 0 and computer_choice == 1) or 
     (player_choice == 1 and computer_choice == 2) or 
     (player_choice == 2 and computer_choice == 0):
    print("你赢了！🎉")
else:
    print("你输了！😢")

列表（List)

增加元素

删除元素

修改元素

查找元素

列表的切片

排序和反序方法

元组（Tuple）

定义元组

可变元组

字典（Dict）

定义字典

删除键值

修改键值

查找键值

其他操作

集合(Set):无序，去重，{ }

add 增加元素

remove 删除元素

关系测试

交集

反交集:交集的补集

并集

差集

子集与超集

frozenset不可变集合

==数据结构总结==

流程控制

判断语句

多分支判断

循环语句 – while

循环终止语句

break

continue

while …… else

循环语句for

遍历列表

遍历字符串

enumerate

range

小游戏案例

更多文章

Redis 数据库介绍和环境准备

Mysql 单表查询和字符集介绍

MySQL 索引介绍

MySQL 执行计划（explain)

字典`（Dict）`

`frozenset`不可变集合