第9节课 - Python基础笔记 - 序列及推导式

MikaGod

已于 2023-05-14 22:34:39 修改

阅读量65

点赞数

分类专栏： python基础文章标签：笔记 python

于 2023-05-14 22:31:58 首次发布

本文链接：https://blog.csdn.net/MikaGod/article/details/130674581

版权

python基础专栏收录该内容

1 篇文章 0 订阅

订阅专栏

列表 list

列表可以存放任意数据类型

列表的创建

# ------------------------------------------------------
# 手动创建
li1 = [1,2,3,4,5,6,7,8,9]
print(li1,type(li1))
# 自动创建
li2 = list('123456789') # 中间参数必须是可迭代对象
print(li2,type(li2))
# ------------------------------------------------------

使用索引和切片访问列表

# ------------------------------------------------------
name_list = ['张三','李四','王五','赵六']
print(name_list[3]) # 索引处理 取值
print(name_list[0:4:2]) # 切片处理 取值

# 获取索引值
name_list.index("李四") # 1
# 获取值出现次数
name_list.count("王五") # 1
# ------------------------------------------------------
# len()：访问列表长度，即列表中数据的个数
# 统计长度 不管是列表还是字符串都可以统计
print(len(name_list)) # 参数为可迭代对象 返回4
# ------------------------------------------------------
# in 判断子数据是否在列表中，字符串也使用
if '张三' in name_list:
    print(True)
else:
    print(False)
# ------------------------------------------------------

给列表追加元素

# ------------------------------------------------------
# append 列表是可变数据类型
# 若传的是可迭代对象，不遍历即可追加
li3 = ["1","2","3"]
li3.append(["1","2"])
print(li3)
# ------------------------------------------------------
# extend 给列表追加或扩展元素
# 若传的是可迭代对象，则遍历后再追加
li4 = ["1","2","3","4"]
li4.extend(["8",'9'])
print(li4) # ['1', '2', '3', '4', '8', '9']
# ------------------------------------------------------
# insert 给列表插入元素
li5 = ["1","2","3"]
li5.insert(1,"4") # 在"2"前面插入"1"
print(li5)
# ------------------------------------------------------

给列表删除元素

# ------------------------------------------------------
# del 与 clear()
li6 = ["1","2","3"]
del li6[1]
print(li6) # 把值连同内存都删掉

li6.clear(0) # 只删除值不删除内存 即 清空
# ------------------------------------------------------
# pop()、remove()
num = [40,36,89,2,36,100,7]
num.pop(3) # 参数为索引值，把2删除了

num1 = [40,36,89,2,36,100,7]
num1.remove(2) # 参数为具体值，把2删除了
# ------------------------------------------------------

给列表修改元素

# ------------------------------------------------------
# 索引修改
name_list = ['张三','李四','王五','赵六']
print(name_list[0]) #   只需要将值重新赋值即可
name_list[0] = '阿坤'
print(name_list)
# ------------------------------------------------------
# 切片修改
nums = [40,36,89,2,36,100,7]
#   修改前三个元素的值（不包含第4个元素）
nums[0:3] = [45.25, -77, -52.5]
print(nums)
# ------------------------------------------------------

给列表元素排序

# ------------------------------------------------------
# 给列表的元素进行 正或反向排序
li = [2,3,5,6,1,4,8]
li.sort(reverse=False) # 列表.sort()是正向排序方法，reverse是反向参数为True则反向排序
print(li)
# ------------------------------------------------------

列表的复制

# ------------------------------------------------------
# 列表的复制
n1 = ['张三','李四','王五','赵六']
n2 = n1.copy() # 列表.copy() 复制值是值相同但是id值不同
print(f'n1的id：{id(n1)} \nn2的id：{id(n2)}')
# ------------------------------------------------------

遍历输出列表

# ------------------------------------------------------
# 遍历输出列表
nl = ['Tom','Sam','Rose']
# ------------------------------------------------------
i = 0
while i < len(nl):
    print(nl[i],end=' ')    #Tom Sam Rose
    i+=1
print()
# ------------------------------------------------------
nl = ['Sam','Danny','Lydia']
for i in range(0,3):
    print(nl[i],end=' ')
print()
# ------------------------------------------------------

*列表reverser()与reverserd()的区别

# ------------------------------------------------------
# 列表a
a = [1,2,3,4,5,6,7]
# ------------------------------------------------------
# 细节
b = list(reversed(a)) # 反转元素顺序，内存地址改变，返回可迭代对象
a.reverse() # 反转元素顺序，内存地址不变，还是原来的对象，无返回值
# ------------------------------------------------------
# 分别输出 值 和 内存地址
print(a,b,id(a),id(b)) # [7, 6, 5, 4, 3, 2, 1] [7, 6, 5, 4, 3, 2, 1] 2633704624648 2633710693704
# ------------------------------------------------------
# 分别查看其内容 及 类型
print(a.reverse(),type(None)) # 为什么打印结果为None呢！因为reverse()函数没有返回值
print(reversed(a),type(reversed(a))) # 为什么打印结果为列表可迭代对象呢！因为reverse()函数返回一个可迭代对象
# ------------------------------------------------------

元组 tuple

元组的创建与修改

# 元组是不可变类型，不能直接修改的，改变后则会生成一个新的内存地址
# ------------------------------------------------------
# 元组的创建

# 直接创建
tup1 = (1,2,3) # (1, 2, 3)
tup2 = (1,) # (1,)

# tuple()创建
top3 = tuple("hello") # ('h', 'e', 'l', 'l', 'o')
print(tup1,tup2,top3)
# ------------------------------------------------------
# 若元组中含列表，那可以修改元组中的列表
tup0 = (1, ['a','b','c'], 2)
print(id(tup0))
tup0[1][0] = 'aaa'
print(tup0) # (1, ['aaa', 'b', 'c'], 2)
print(id(tup0))
# 元组可强转为列表后再修改
tup0 = (10, 20, 30)
tup0 = list(tup0)
tup0[1] = 55
print(tup0) # [10, 55, 30]
# ------------------------------------------------------
# 关于可变类型与不可变类型
"""
可用 id() 查看 其内存地址
内存地址改变即为不可变类型
内存地址不变即为可变类型
"""
# ------------------------------------------------------

字典 dictionary

字典的优点

# ------------------------------------------------------
# 字典顺序与数据顺序没有关系，即不可用索引取值
li = [
    ['小红',22,150,150],
    ['小兰',22,165,145],
    ['小紫',24,160,100]
] # 看不出 身高 体重 分别是哪个数据
# ------------------------------------------------------
li2 = [
    {'姓名': '小红'}, {'年龄': '22'}, {'身高': '150cm'}, {'体重': '150斤'},
    {'姓名': '小兰'}, {'年龄': '22'}, {'身高': '165cm'}, {'体重': '145斤'},
    {'姓名': '小红'}, {'年龄': '24'}, {'身高': '160cm'}, {'体重': '100斤'}
] # 能准确描述信息
# ------------------------------------------------------

字典的定义

# ------------------------------------------------------
# 直接定义
dict1 = {'name':'张三','age':20,'gender':'男'}
# ------------------------------------------------------
# dict()函数定义
a_dict = dict(name='DYX',age=24) # 键:值对
print(a_dict,type(a_dict)) # {'name': 'DYX', 'age': 24} <class 'dict'>
# ------------------------------------------------------

关于字典的键和值

# ------------------------------------------------------
# 关于字典的键和值
dict8 = {(123):'张三','age':20,'gender':'男','name':'mika'}
print(dict8)
"""
字典中，键是唯一的，且必须是不可变类型！
值可以是任意类型的！
"""
# ------------------------------------------------------

字典的查看

# ------------------------------------------------------
# 根据键查找值
dict10 = {(123,):'张三','age':20,'gender':'男','name':'mika'}
print(dict10.get((123,)))
print(dict10['age']) # 如果字典里面嵌套有字典，无法通过 get() 直接获取 value:
# ------------------------------------------------------
# 键相关
dict10.keys() # 获取所有键
dict10.values() # 获取所有值
dict10.items() # 获取所有键值对
# ------------------------------------------------------
# 遍历字典
for i,j in dict10.items():
    print(i,j)
# ------------------------------------------------------

字典的增加与修改

# ------------------------------------------------------
# 字典的增加与修改
# ------------------------------------------------------
# 增加元素
dict11 = {'name':'张三','age':20,'gender':'男'}
dict11['name'] = 'mika' # 修改 重新赋值
print(dict11) # {'name': 'mika', 'age': 20, 'gender': '男'}
# ------------------------------------------------------
# 增加元素（键是字符串的时候可用update()函数）
dict99 = {"芭比":18,'娃娃':20}
dict99.update(芭比=20) # 参数：键=新值
print(dict99) # {'芭比': 20, '娃娃': 20}
# ------------------------------------------------------

字典覆盖合并且添加元素

# ------------------------------------------------------
# 合并覆盖且添加
dict12 = {(123):'张三','age':20,'gender':'男','id':'mika'}
dict13 = {'name':'张三','age':20,'gender':'男'}
dict12.update(dict13) # dict12与dict13覆盖合并，且把dict13里dict12没有的元素添加给dict12
print(dict12) # 修改的是dict12对象本身，内存地址不变
# ------------------------------------------------------

删除或清空字典

# ------------------------------------------------------
"""
1. clear () 删除字典内所有元素
2. pop () 删除字典给定键key所对应的值, 返回被删除的值
3. popitem () 随机返回并删除字典中的一对键和值
4. del 删除单一元素的值, 或 清空整个字典
"""
# ------------------------------------------------------
# 删除元素
dict03 = {'name':'张三','age':20,'gender':'男'}
del dict03['name'] # 删除 键'name' 及 对应的值
pd = dict03.pop("age") # 删除 键'age' 及 对应的值 且 返回对应的值
print(dict03,pd) # {'gender': '男'} 20
# ------------------------------------------------------
# 字典清空
dict12 = {'name':'张三','age':20,'gender':'男','name':'mika'}
dict12.clear() # 清空dict12的内容
print(dict12) # {} 空字典
# ------------------------------------------------------

集合 set

集合的概念与创建

'''
集合是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
'''

集合的基本操作

添加元素 add()、update()

# ------------------------------------------------------
# add()函数添加元素,只能添加一个元素，如果元素已存在，则不进行任何操作。
set1 = set()
set1.add("美眉")
print(set1) # {'美眉'}
# ------------------------------------------------------
# update()添加元素，参数可以是可迭代对象，若参数是可迭代对象就会遍历添加
set2 = set()
set2.update([1,2,3],'娃娃',"美女")
print(set2) # {1, 2, 3, '美', '娃', '女'}
# ------------------------------------------------------

移除元素 remove()、discard()、pop()

# ------------------------------------------------------
# remove()函数移除元素，只能移除一个元素，如果元素不存在，则报错 
set1 = {'美眉',520,'娃娃'}
set1.remove(520)
print(set1) # {'娃娃', '美眉'}
# ------------------------------------------------------
# discard()函数移除元素，如果元素不存在，不报错
set2 = {'美眉',520,'娃娃'}
set2.discard(52)
print(set2) # {520, '娃娃', '美眉'}
# ------------------------------------------------------
# pop()函数 可以随机删除集合中的一个元素
set3 = {"Google", "Runoob", "Taobao", "Facebook"}
set3.pop()
print(set3) # 集合的 pop方法 会对集合进行无序的排列，然后将左面第一个元素进行删除。
# ------------------------------------------------------

计算元素个数 len()

# ------------------------------------------------------
set0 = {5,'娃娃','ai',6}
lset0 = len(set0)
print(lset0) # 4
# ------------------------------------------------------

清空集合 clear()

# ------------------------------------------------------
set0855 = {'256',3605,'wdfaf6','666'}
set0855.clear()
print(set0855) # set()
# ------------------------------------------------------

判断元素是否存在于集合中 * in ***

# ------------------------------------------------------
seT = {666,777,888,999}
TF1 = 886 in seT
TF2 = 666 in seT
print(TF1,TF2) # False True
# ------------------------------------------------------

推导式（简单示例）

# ------------------------------------------------------
# 推导式都是对可变数据类型来使用的
# ------------------------------------------------------
# 列表推导式
new_li = [i for i in range(1,11) if i % 2 == 0] # [返回的值 循环表达式 条件判断]
print(new_li) # [2, 4, 6, 8, 10]
# ------------------------------------------------------
# 字典推导式
dic = {i: i ** 2 for i in range(1,6)} # {键: 返回的值 循环表达式 条件判断}
print(dic) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# ------------------------------------------------------
# 集合推导式
a = {x for x in 'abracadabra' if x not in 'abc'} # {返回的值 循环表达式 条件判断} 
print(a) # {'d', 'r'}
# ------------------------------------------------------
# 元组推导式（无意义）
# 返回的是一个生成器对象(generator),需要用tuple()转成元组
tup = tuple(x for x in range(1,10)) 
print(tup) # (1, 2, 3, 4, 5, 6, 7, 8, 9)
# ------------------------------------------------------

公共方法（补充内容）

enumerate() 函数

# ------------------------------------------------------
'''
enumerate()函数用于 获取可迭代对象的 元素 和 索引值
语法：enumerate(可遍历对象,start=0)
start参数用来设置遍历数据的下标的起始值，默认为0
'''
# ------------------------------------------------------
li = ['safa',f"85{6}",6641,'dagagf',9978974685986416841684,{1,2,3}]
for index,elements in enumerate(li):
    print(f'下标={index},元素={elements}')
# ------------------------------------------------------
'''
运行结果(索引值, 元素)：
下标=0,元素=safa
下标=1,元素=856
下标=2,元素=6641
下标=3,元素=dagagf
下标=4,元素=9978974685986416841684
下标=5,元素={1, 2, 3}
'''
# ------------------------------------------------------

zip() 高阶函数

# 这有两个列表
a = [5,6,7,8]
b = ['娃娃','美女','清纯']

# zip() 压缩
zipped = zip(a,b) # 返回一个zip压缩包对象 赋值给zipped变量
print(zipped) # <zip object at 0x0000026929BDBEC8>
''' print(list(zipped)) # [(5, '娃娃'), (6, '美女'), (7, '清纯')] '''
# 转成列表即可实现可视化，根据索引一一对应，多的不管

# zip(* )解压
decompression = zip(*zipped) # <zip object at 0x000001E334A1E0C8>
decompression1,decompression2 = list(decompression)
print(decompression)
print(decompression1,decompression2) # (5, 6, 7) ('娃娃', '美女', '清纯')