python基础语法

I＇m happy

于 2024-08-23 20:13:03 发布

阅读量346

点赞数 8

文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_54066292/article/details/141473741

版权

python容器类型元组,字典和集合

元组

概述: 属于容器类型的一种,但可以同时储存多个元素,但元组内容是不可变的.
简单理解:列表与元组的区别
- 列表 = 同时存储多个元素+元素内容可变.
- 元组 = 同时存储多个元素+元素内容不可变.
格式:

tuple1 = (值1, 值2, 值3...)
tuple2 = tuple()
tuple3 = ()
tuple4 = (10,)
tuple5 = (10)

下标和切片:
- 下标:就是索引,元组和列表,字符串一样,每个元素都有下标,且默认从零开始.
- 切片: 元组支持切片,写法和列表,字符串一致.
常用函数: index(), count(), len()
注意:
- 1.如果元组只有1个元素,该元素后必须加逗号.
- 2.如果元组只有且后边没有加逗号,就说明它是一个该类型的变量.

# 需求1: 演示如何定义元组.
# 1. 演示如何定义元组.
tuple1 = (10, 20, 30, 40, 50)
tuple2 = tuple()
tuple3 = ()
tuple4 = (10,)
tuple5 = (10)
tuple6 = ('aa')

# 2. 打印上述的变量.
print(tuple1)   # (10, 20, 30, 40, 50)
print(tuple2)   # ()
print(tuple3)   # ()
print(tuple4)   # (10,)
print(tuple5)   # 10
print(tuple6)   # aa

# 3. 打印上述的变量的 数据类型.
print(type(tuple1)) # <class 'tuple'>
print(type(tuple2)) # <class 'tuple'>
print(type(tuple3)) # <class 'tuple'>
print(type(tuple4)) # <class 'tuple'>
print(type(tuple5)) # <class 'int'>
print(type(tuple6)) # <class 'str'>
print('-' * 30)

# 需求2: 演示元组的 索引 和 切片操作.
tuple7 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
# 根据索引, 获取 元组的元素值.
print(tuple7[3])    # 4

# 尝试修改元组的元素值.
# tuple7[3] = 200     # 报错, 因为元组内容是 不可变 的.

# 元组切片.
print(tuple7[2:6])     # [3, 4, 5, 6]

# 打印元组的内容.
print(f'tuple7: {tuple7}')
print("-" * 30)


# 需求3: 元组的常用函数.
tuple8 = (1, 2, 3, 4, 5, 3, 5)

print(tuple8.index(3))              # 2, 第一次出现的位置.
# print(tuple8.index(30))           # 找不到就报错.
print(tuple8.count(3))              # 2次
print(f'元组的长度为: {len(tuple8)}') # 7
print("-" * 30)


# 4. 元组的细节问题, 即: 元组嵌套列表.
# 前提: 元组是属于容器类型的一种, 它属于 不可变类型, 但是当: 元组嵌套列表的时候, 其内部列表的值是可以修改的, 但是改 列表的地址值是不变的.
t1 = (1, 2, 3, ['a', 'b', 'c'])
print(f'修改前: {t1}')

# 需求, 把 'b' => 'AI30期'
# print(t1[3])
t1[3][1] = 'z'

print(f'修改后: {t1}')

字典

概述: 字典属于容器类型一种,用于存储多个元素,存储的是键值对数据.
格式:
- dict1 ={键:值,键:值,…}
- dict2 = dict()
- dict3 = {}
特点:
- 键具有唯一性,而值可以重复.

演示定义字典

# 1. 演示如何定义字典.
#         键       值      键   值       键值对数据
dict1 = {'name': '张三', 'age': 23, 'gender': 'male'}
dict2 = dict()
dict3 = {}
dict4 = {10, 20, 30, 40, 50}        # 这个可不是字典, 而是1个集合(set)

# 2. 打印字典.
print(dict1)
print(dict2)
print(dict3)
print(dict4)

# 3. 打印字典的类型.
print(type(dict1))  # <class 'dict'>
print(type(dict2))  # <class 'dict'>
print(type(dict3))  # <class 'dict'>
print(type(dict4))  # <class 'set'>

字典详解:常见操作

增/改:字典名[键] = 值键存在就修改,不存在就新增.

# 1. 定义字典, 添加元素.
dict1 = {'杨过': '大雕', '郭靖': '杨康', '阿东': '王二麻子'}

# 2. 演示上述的函数.
# 增
dict1['乔峰'] = '阿朱'  # 键不存在就添加
dict1['阿紫'] = '阿朱'  # 键不存在就添加

查
get(键名,默认值)

dict1 = ['杨过': '大雕', '郭靖': '杨康', '阿东': '王二麻子']
# 查
# get(键名,默认值)根据键获取对应的值,如果不存在就返回默认值,默认值不写为:None
print(dict1.get('杨过'))   # 结果为 大雕
print(dict1.get('阿朱'))    #不存在该键 结果为None

keys() 查询所有键

print(dict1.keys())       # dict_keys(['杨过', '阿东', '乔峰', '阿紫'])

values() 获取所有值

print(dict1.values())     # dict_values(['大雕', '王二麻子', '阿朱', '阿朱'])

items() 获取所有键值对数据,并封装成:列表嵌套元组的形式.

print(dict1.items())
#结果为 dict_items([('杨过', '大雕'), ('阿东', '王二麻子'), ('乔峰', '阿朱'), ('阿紫', '阿朱')])

dict1['郭靖'] = '黄蓉'  # 键存在, 就覆盖(用新值 覆盖 旧值)

字典的遍历

演示如何遍历字典即:逐个获取字典中键值对的过程.

# 1. 定义字典, 记录元素.
dict1 = {'name': '乔峰', 'age': 41, 'gender': '男', 'kongfu': '降龙十八掌'}

# 思路1: 根据 键 获取其对应的 值.       理解为: 根据丈夫 找 妻子.
# step1: 获取所有的键.
keys = dict1.keys()

# step2: 遍历, 获取到 每个键.
for key in keys:
    # key 就是字典的中的每个键, 根据键 获取值.
    value = dict1.get(key)
    # step3: 打印结果.
    print(key, value)
print('-' * 30)

# 上述格式简化版
for key in dict1.keys():
    print(key, dict1.get(key))
print('-' * 30)

# 思路2: 根据 键值对 找键和值.         理解为: 根据 结婚证 找丈夫和妻子.
# step1: 获取所有的键值对.
items = dict1.items()
# step2: 遍历, 获取到每一组 键值对.
for item in items:
    # item就是每组键值对的 元组形式, 即: (键, 值)
    # step3: 从item中获取到 键 和 值.
    key = item[0]
    value = item[1]
    # step4: 打印结果
    print(key, value)
print('-' * 30)

# 合并版.
for item in dict1.items():
    print(item[0], item[1])
print('-' * 30)

集合

概述:属于容器类型一种,属于可变类型.
格式:
- set1 ={值1,值2,值3…}
- set2 = set{}
- set3= {} # 单纯这种属于在定义字典不是集合.
特点: 无序(元素的存和取的顺序不一致),唯一
应用场景:自动去重重复的元素.

# # 1. 演示: 集合的定义格式.
# set1 = {10, 20, 'aa', 50, 'cc', 'bb', 20, 'cc'}
# set2 = set()
# set3 = {}           # 这个不是在定义集合, 而是在定义字典.
#
# # 2. 打印上述变量的 数据类型.
# print(type(set1))   # <class 'set'>
# print(type(set2))   # <class 'set'>
# print(type(set3))   # <class 'dict'>
#
# # 3. 打印上述变量的值.
# print(set1) # {50, 10, 20, 'bb', 'cc', 'aa'}, 元素存取顺序不同 = 无序.
# print(set2) # set()
# print(set3) # {}
# print("-" * 30)

# 4. 需求: 列表元素去重(保留1个)
# 思路1: 列表 => 集合, 自动去重 => 列表
list1 = ['aa', 'bb', 'cc', 'cc', 'cc', 'dd', 'bb', 'cc']
list2 = []
# step1: 把 列表 => 集合, 会自动去重.
# set1 = set(list1)
# # step2: 把去重后的 集合 => 列表.
# list2 = list(set1)
# step3: 打印结果.
# print(f'去重后, 结果为: {list2}')

容器类型公共运算符

概述:这些运算符可作用到容器类型中
常用如下:

 +           合并(拼接), 适用于: 字符串, 列表, 元组.
 *           复制, 适用于: 字符串, 列表, 元组.
 in          是否包含, 适用于: 字符串, 列表, 元组, 字典.
 not in      是否不包含, 适用于: 字符串, 列表, 元组, 字典.

注意:
- in, not in 针对于字典的时候只作用于键.

需求: 演示上述的 公共的运算符.
# +           合并(拼接), 适用于: 字符串, 列表, 元组.
print('abc' + 'xyz')
print([1, 2, 3] + ['a', 'b', 'c'])
print((1, 2, 3) + ('a', 'b', 'c'))
print('-' * 30)

# *           复制, 适用于: 字符串, 列表, 元组.
print('abc' * 2)
print([1, 2, 3] * 2)
print((1, 2, 3) * 2)
print('-' * 30)

# in          是否包含, 适用于: 字符串, 列表, 元组, 字典.
print('a' in 'abc')             # True
print(10 in [1, 2, 3])          # False
print(10 in (10, 2, 3))         # True
print(10 in {10, 2, 3})         # True
print(10 in {1:2, 2:3, 10:5})   # True, 如果判断字典, 则判断的是: 键(key)
print(10 in {1:2, 2:3, 5:10})   # False, 如果判断字典, 则判断的是: 键(key)
print('-' * 30)

# not in      是否不包含, 适用于: 字符串, 列表, 元组, 字典.
print('a' not in 'abc')
print(10 not in [1, 2, 3])
print(10 not in (10, 2, 3))
print(10 not in {10, 2, 3})
print(10 not in {1:2, 2:3, 10:5})
print(10 not in {1:2, 2:3, 5:10})

容器的公共方法
- 常用如下:

  len()        获取长度的
  del          删除的
  max()        最大值
  min()        最小值
  range(start, end, step)      生成指定区间范围的值. 包左不包右.
  enumerate()  生成列表元素的: 索引 和 值, 封装成 元组形式, 即: (索引, 值)

# 演示 len()        获取长度的
# 1. 字符串
s1 = 'abc'
print(len(s1))

# 2. 列表
print(len([1, 2, 3, 4, 5]))

# 3. 字典
print(len({'a': 1, 'b': 2, 'c': 3}))  # 3
print("-" * 30)

# 演示 del          删除的
# 1. 字符串.
s1 = 'abc'
del s1
# print(s1)

# 2. 列表
list1 = [1, 2, 3, 4, 5]
del list1[0]
del (list1[2])
print(list1)

# 3. 字典
dict1 = {'a': 1, 'b': 2, 'c': 3}
del dict1['a']
del (dict1['c'])
print(dict1)
print("-" * 30)

# 演示 max()        最大值
print(max('abcdefg'))
print(max([1, 2, 3, 4, 5]))
print(max((1, 2, 3, 4, 5)))
print(max({1, 2, 3, 4, 5}))
print(max({'a': 1, 'b': 2, 'c': 1}))    # 只针对于 键.
print("-" * 30)

# 演示 min()        最小值
# 同上, 自测.

# 演示 range(start, end, step)      生成指定区间范围的值. 包左不包右.
print(range(1, 10, 2))  # 生成 1 到 10 的 奇数, 获取: range()对象.
for i in range(1, 10, 2):
    print(i)

print(list(range(1, 10, 2)))    # 把 range() => 列表.
print("-" * 30)

# 演示 enumerate()  生成列表元素的: 索引 和 值.
list1 = ['a', 'b', 'c', 'd', 'e']

for i in list1:
    print(i)        # 'a', 'b', 'c', 'd', 'e', 它们的索引分别是: 0, 1, 2, 3, 4

# for i in enumerate(list1):    # 默认: 索引是从 0 开始的.
for i in enumerate(list1, 5):   # 指定 索引从 5 开始.
    print(i)        # 把列表元素和其索引封装成元组, 即: (索引, 值)
print('-' * 30)

# 扩展, 看看就行了, 把 列表 => 字典.  下午我们会详细讲解 推导式.
dict1 = {item[0]:item[1] for item in enumerate(list1)}
print(dict1)推导式

推导式

概述:推倒式也叫解析式,即:根据特定的规则生成1个数据序列的操作.
可分为:
列表推导式
格式: 列表 = [变量名 for i in … if 条件…]

# 需求1: 创建0 ~ 9的列表.
# 思路1: 自定义 while 或者 for循环搞定.
list1 = []
for i in range(10):
    list1.append(i)
print(list1)

# 思路2: 列表推导式写法.
list2 = [i for i in range(10)]  # 效果同上.
print(list2)
print('-' * 30)



# 需求2: 创建1个0 ~ 9的 偶数列表.
# 方式1: 自定义 while 或者 for循环搞定.
list3 = []
for i in range(0, 10, 2):
    list3.append(i)
print(list3)

# 方式2: 列表推导式写法, 结合 步长.
list4 = [i for i in range(0, 10, 2)]
print(list4)

# 方式3: 列表推导式写法, 结合 if判断.
list5 = [i for i in range(10) if i % 2 == 0]
print(list5)
print('-' * 30)



# 需求3: 创建列表 => [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
# 方式1: 分解版, 自定义for 或者 while循环搞定.
list6 = []
for i in range(1, 3):       # i的值: 1, 2
    for j in range(3):      # j的值: 0, 1, 2
        # 把元素添加到列表中.
        # my_tuple = (i, j)
        # list6.append(my_tuple)
        list6.append((i, j))
print(list6)

# 方式2: 列表推导式写法.
#                  外循环                内循环     =  外循环执行一次, 内循环指定一圈(一轮)
list7 = [(i, j) for i in range(1, 3) for j in range(3)]    # 效果同上.
print(list7)

字典推导式
- :推导式也叫解析式,即根据特定规则生成1个数据列表的操作.

演示

# 案例1: 创建1个字典, key是1~5, 值是这个数字的平方.
# 方式1: for, while 手动实现.
dict1 = {}
for i in range(1, 6):
    dict1[i] = i ** 2
print(dict1)

# 方式2: 字典推导式.
#         键值对
dict2 = {i : i ** 2 for i in range(1, 6)}
print(dict2)
print("-" * 30)



# 案例2: 将两个列表合并为1个字典.
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']

# 方式1: for, while手动实现.
dict3 = {}
for i in range(len(list1)):     # i的值: 0, 1, 2
    # i 就是 列表中的每个元素的 索引, 把索引对应的值 添加到 字典中即可.
    dict3[list1[i]]  = list2[i]
print(dict3)


# 方式2: 字典推导式.
dict4 = {list1[i] : list2[i] for i in range(len(list1))}    # i的值:0, 1, 2
print(dict4)
print("-" * 30)


# 案例3 演示: 集合推导式 => 默认具有 元素去重的功能.
# 1. 定义1个列表, 记录一些元素.
list1 = [1, 1, 2]

# 2. 集合推导式实现, 获取的元素值为 上述元素的平方结果.
set2 = {i ** 2 for i in list1}     # i的值: 1, 1, 2
print(set2)     # {1, 4}    因为集合默认会: 去重.

集合推导式
注:具有元素去重的功能

# 1. 定义1个列表, 记录一些元素.
list1 = [1, 1, 2]

# 2. 集合推导式实现, 获取的元素值为 上述元素的平方结果.
set2 = {i ** 2 for i in list1}     # i的值: 1, 1, 2
print(set2)     # {1, 4}    因为集合默认会: 去重.