Python基础02——序列&条件循环&字典

每天都要努力学习的阿凯

已于 2022-09-19 00:02:33 修改

阅读量335

点赞数 1

分类专栏： Python基础文章标签： python 开发语言

于 2022-07-25 10:14:37 首次发布

本文链接：https://blog.csdn.net/ZCaesarK/article/details/125969396

版权

Python基础专栏收录该内容

2 篇文章 0 订阅

订阅专栏

序列

什么是序列？

序列是一python的一种数据结构，它的成员都是有序排列的，并且可以通过下标偏移量访问到它的一个或几个成员。（正索引从首部访问，副索引从尾部访问）。
字符串、元组和列表都是序列，其实是三个继承自序列类的类，他们都可以通过下标索引访问它的成员，都有继承自序列类的共同的方法。
序列还是容器（可以包含其他对象的对象）的一种，另一种主要的容器是字典。

序列的通用操作

索引

#定义一个字符串序列
greeting = 'Hello Python'

#通过索引0访问这个序列的第一个元素，并输出  H
print(greeting[0])

#通过索引-1访问这个序列的最后一个元素，并输出  n
print(greeting[-1])

# 可以直接对序列的字面量进行索引操作，无需先赋值给变量
print((1, 2, 3, 4)[2])
print('Hello'[0])

#如果函数的返回是一个序列，也可以直接对其进行索引操作
str01 = input('year:')[2]
print(str01)

注意事项 :

python 没有字符类型，所以通过索引获取到的其实是一个单字符的字符串
当你使用负数索引时，Python将从右（即从最后一个元素）开始往左数

# 讲输入数字以指定年月日的日期打印出来
months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November',
          'December']

# 指定一个包含英文字母结尾的字符串列表
ending = ['st', 'nd', 'rd'] + 17 * ['th'] + ['st', 'nd', 'rd'] + 7 * ['th'] + ['st']

print(ending)

year = input("Year: ")
month = input(("Month(1-12):"))
day = input("day(1-31): ")

month_num = int(month)
day_num = int(day)

month_name = months[month_num-1]
ordinal = day + ending[day_num]

print(month_name + '\t' + ordinal + '\t' + year)

'''
运行结果：
['st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'st']
Year: 2021
Month(1-12):10
day(1-31): 7
October	7th	2021
'''

切片

切片操作可以访问特定范围内的元素

url = 'https://www.cnblogs.com/kay08/'
print(len(url))

print(url[8:24])

print(url[-6:-1])

# 直接截取到末尾
print(url[8:])

# 从第一个元素开始
print(url[:23])

# 截取所有
print(url[:])

'''
30
www.cnblogs.com/
kay08
www.cnblogs.com/kay08/
https://www.cnblogs.com
https://www.cnblogs.com/kay08/
'''

注意事项：

切片操作的第一个索引表示从哪个索引开始切片，第二个索引表示切片后剩余第一个元素的索引。
省略左边的索引表示从开头开始截取，省略右边的索引表示截取到末尾。
切片操作返回包含请求元素的新列表，返回列表的浅拷贝（只拷贝值，不拷贝引用）

切片的步长设置

正常默认情况下的步长为1，python允许设置更大的步长，或者是从终点向起始点进行切片

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

# 默认情况下的切片操作
print(nums[:8])

# 设置步长为2
print(nums[:9:2])
print(nums[1:9:2])

# 简写索引下设置步长
print(nums[::4])

# 设置步长为负数，从终点向起始点切片
print(nums[::-2])

'''
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 3, 5, 7, 9]
[2, 4, 6, 8]
[1, 5, 9]
[11, 9, 7, 5, 3, 1]
'''

相加

num1 = [2, 4, 6, 8, 10]
num2 = [1, 3, 5, 7, 9]

nums = num1 + num2

print(nums)
nums.sort()
print(nums)

'''
[2, 4, 6, 8, 10, 1, 3, 5, 7, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
'''

**注意事项：**序列相加只支持同类型的序列进行相加，比如字符串和列表相加就会报错。

相乘

pythons = 'python\t' * 5
print(pythons)

print([2021] * 10)

'''
python	python	python	python	python	
[2021, 2021, 2021, 2021, 2021, 2021, 2021, 2021, 2021, 2021]
'''

成员资格检查

使用关键字 in来进行资格检查，在序列中则返回True，否则返回False

# 检查用户名和PIN码
databases = [
    ['albert', '1234'],
    ['dilbert', '5678'],
    ['smith', '1245'],
    ['jones', '6688']
]

username = input('Username: ')
pin = input("PIN: ")

if [username, pin] in databases:
    print('Access granted!')

长度、最大值和最小值

# 计算长度
str1 = 'I love Python'
print(len(str1))

num = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print('长度：' + str(len(num)))
print('最小值：' + str(min(num)))
print('最大值：' + str(max(num)))

'''
# 计算长度
str1 = 'I love Python'
print(len(str1))

num = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print('长度：' + str(len(num)))
print('最小值：' + str(min(num)))
print('最大值：' + str(max(num)))

'''

列表

什么是列表？

列表是序列的一种，不同于元组和字符串，列表是可变的，有许多属于列表这个类的独特方法可以用来改变列表。
列表可以包含不同类型的元素，但一般情况下，各个元素的类型相同

可以使用list函数来创建列表：

>>> print(list('Hello'))
['H', 'e', 'l', 'l', 'o']

基本的列表操作

修改列表：给列表赋值

num = [1, 2, 3, 4, 5, 6, 7, 8]

num[0] = 0

print(num)

'''
[0, 2, 3, 4, 5, 6, 7, 8]
'''

删除元素

num = [1, 2, 3, 4, 5, 6, 7, 8]
del num[0]

print(num)

'''
[2, 3, 4, 5, 6, 7, 8]
'''

给切片赋值

str1 = list('Perl')

# 可将切片替换为长度与其不同的序列。
str1[1:] = list('ython')

print(str1)

num = [2, 3, 4, 5, 6, 7, 8]

# 在不替换原有元素的情况下插入新元素
num[0:0] = [1]
print(num)

# 给切片赋空值，相当于删除
num = [1,2,3,4,5]

num[1:4]  = []

print(num)

'''
['P', 'y', 't', 'h', 'o', 'n']
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 5]
'''

列表方法

append()

lst = [1, 2, 3, 4]

# append只是修改旧列表，不会有新的列表返回
# append是在列表的末尾添加元素
lst.append(5)

print(lst)
#[1,2,3,4,5]

clear()

lst = [1, 2, 3, 4, 5, 6, 7, 8]

print(lst)
lst.clear()
# 清空元素
print(lst)

'''
[1, 2, 3, 4, 5, 6, 7, 8]
[]
'''

copy()

# 常规复制只是讲另一个变量关联到原来的变量，如果两个变量要指向不同的列表，则需要使用copy()方法复制一个原来变量的副本与新变量关联
# copy也是浅拷贝
lst3 = [1, 2, 3, 4]

# 常规复制
lst4 = lst3

lst4[0] = 2

print('常规：')
print(lst3)

lst3 = [1, 2, 3, 4]

lst4 = lst3.copy()
lst4[0] = 2

print('copy：')
print(lst3)

'''
常规：
[2, 2, 3, 4]
copy：
[1, 2, 3, 4]
'''

count()

# count()方法用来计算某个元素在列表中出现多少次
lst5 = [1,2,2,3,2,1,3,4,5,6,6,23,32,21,32]

print(lst5.count(2))

extend()

# extend()方法虽然类似于拼接，但是跟拼接不同的是，extend方法会修改原来的列表，而拼接是返回一个新列表
a = [1, 2, 3]
b = [4, 5, 6]

a.extend(b)
print(a)

index()

#index()方法用来查找指定元素第一次出现的索引
names = ['jack', 'rose', 'jack', 'bin', 'lili', 'kay',1,2,3,4,'kay']
print(names.index('kay'))

'''
5
'''

insert()

# insert()方法用来往列表指定位置插入一个对象
lst6 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
lst6.insert(5,'yeah!')

print(lst6)

'''
[1, 2, 3, 4, 5, 'yeah!', 6, 7, 8, 9, 10]
'''

pop()

# pop()用来删除列表中的最后一个元素，并返回这一元素
# pop()是唯一既修改列表又返回一个非None值的列表方法。、

lst7 = [1,2,3,4,5,56]
a = lst7.pop()

print(a)
print(lst7)

remove()

# romove()方法是用于删除第一个为指定值的元素,就地修改，不返回值
names2 = ['jack', 'rose', 'jack', 'bin', 'lili', 'kay',1,2,3,4,'kay']
names2.remove('jack')

print(names2)

'''
['rose', 'jack', 'bin', 'lili', 'kay',1,2,3,4,'kay']
'''

reverse()

# 方法reverse按相反的顺序排列列表中的元素
nums = [1,2,3]
nums.reverse()
reversed(nums)

print(nums)

'''
[3, 2, 1]
'''

sort()

# sort()方法按照字典顺序用来给列表进行排序,也是就地更改，不返回新列表
nums = [5,3,2,5,6,7,3,21,32,5,64,1]
nums.sort()

print(nums)

print('--------------------------')
# 如果需要保留原列表，讲排序后的列表给新列表可以使用sorted()函数
nums2 = [2,3,4,1,4,5,6,5,3,1,6,678,9,1,0]
a = sorted(nums2)

print(nums2)
print(a)

'''
[1, 2, 3, 3, 5, 5, 5, 6, 7, 21, 32, 64]
--------------------------
[2, 3, 4, 1, 4, 5, 6, 5, 3, 1, 6, 678, 9, 1, 0]
[0, 1, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 9, 678]
'''

高级排序

sort和sorted函数有参数key和reverse，reverse为true时排序反转，排序按字典顺序排

生成列表的方法

range(first_num,last_num)函数可以返回给定参数范围内的一数字列表，范围是[first_num,last_num)

nums = []
for num in range(1,11):
    nums.append(num)


print(nums)
#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 可以加上第三个参数表示增加的步长，默认是1
nums.clear()
for num in range(0,31,5):
    nums.append(num)

print(nums)
# [0, 5, 10, 15, 20, 25, 30]

利用列表解析一行生成列表的代码

# 左边定义一个列表的变量，右边是一个for循环获取元素值然后一个表达式处理获取到的元素，最终生成一个列表
# num**x表示num的x次方
nums = [value**2 for value in range(1,11)]
print(nums)

元组

什么是元组？

与列表一样，元组也是序列，唯一的差别在于元组是不能修改的。

创建空元组可以是()，但是创建一个只有一个元素的元组则必须要有逗号

(42) == 42
#有逗号的才表示是一个元组
(42,)

>>> 3 * (40+2)
126
>>> 3 * (40+2, )
(42, 42, 42)
>>>

为什么使用元组

可以用作映射里的key。
有些内置函数和方法返回元组。
元组除了不能修改，其余操作跟列表是一样的

字符串

什么是字符串？

字符串是序列的一种，与元组一样也是不可变的
字符串的数据类型为 str，由双引号或者单引号构成。

字符串的基本操作

字符串可以使用序列的通用方法

还有些字符串特有的方法：

使用方法修改字符串的大小写

#方法 title()以首字母大写的方式显示每个单词
name = 'kai zheng'
print(name.title())
--------
# 输出为：Kai Zheng


# 将字符串中的字母全都改为大写：upper()
# 将字符串中的字母全都改为小写：lower()

在字符串中使用变量，可以使用f

first_name = "ada" 
last_name = "lovelace" 
full_name = f"{first_name} {last_name}" 
print(full_name)
#输出为ada lovelace

删除空白

# rstrip()是去除右边的空格
>>>favorite_language = 'python '
>>>favorite_language.rstrip()
'python'
 >>> favorite_language 
'python '


#lstrip()是去除开头的空白，strip()是去除所有空白，效果跟rstrip()是类似的

条件与循环

什么是条件语句？

条件语句就是由if语句构成的判断语句，用来判断是否该执行下一个步骤。

条件语句有什么用？

条件语句能够判断程序是否应该执行下一步的代码，在一些需要我们进行判断，然后再决定是否执行的地方使用。

如何使用条件语句？

条件语句的组成：

if 判断表达式 :
  将要执行的代码块，如果判断为true则执行

---------
#或者是：
if 判断表达式：
	代码块
elif 表达式：
	代码块
  ......
else ：
	代码块
 -------
这适用于有多个分支条件需要判断的情况下

a = 'Porsche'
b = 'Porsche'
# 比较是否相等
# if a==b :
#     print(f'a和b相等,都是{a}')
# else :
#     print('a not equal b')

# 输出：
# a和b相等,都是porsche

# 检查是否相等时，python默认是不忽略大小写的，可以使用lower()方法来转换成小写后再进行比较
# a = 'porSche'
# b = 'porsche'

# if a.lower() == b:
#     print(f'a和b相等,都是{a.lower()}')
# else:
#     print('a not equal b')
#
# print('a的值为', a)
# 输出：
# a和b相等,都是porsche
# a的值为 porSche

# 检查是否不相等，使用!=符号,输出：a not equal to b
# a = 'porSche'
# b = 'porsche'
# if a != b :
#     print('a not equal to b')

# 数值比较与多条件比较,elif就是当if条件不成立时就会进入，一层层判断，如果都不成立则执行else后面的代码。
# 多个判断语句出现的时候，最后也可以不使用else，可以以elif结尾
# 多条件比较可以使用关键字 and ，表示逻辑与（两边都为true时为true）和 or 表示逻辑或（只要有一个true则为true）

a = 18.8
b = 189

if a == b:
    print('a equals b ?', a == b)
elif a > 100:
    print('a>100?', a > 100)
elif a < b:
    print('a<b?', a < b)
elif a >= 100 and a < b:
    print("a>=100 and a<b?", a >= 100 and a < b)
else:
    print('a not equals b ?', a != b)

# 序列的比较还可以使用 in 和 not in

什么是循环语句？

循环语句分为for循环和while循环，是用来循环执行某段代码的。

循环语句有什么作用？

循环语句可以用来处理列表、字典等的元素，可以通过循环取出一个个元素执行特定的操作(增删改查等)。

还可以通过循环语句执行多次相同的操作，知道条件不满足为止。

如何使用循环语句？

for循环

#语法格式:
# for 列表内的单个元素 in 列表名 :
	#循环执行的代码
# 打印披萨列表
pizzas = ['Marinara', 'Durian Pizza', 'Seafood Supreme']
for pizza in pizzas:
    print(f'I like {pizza} so much!')
print(f'I really like Pizza,expecially {pizzas[1]}')

while循环

#不同于for循环用于针对每个元素都执行一个代码块，while循环则是不断执行代码块，知道条件不满足为止
#电影票，编写一个while循环，在其中询问用户的年龄，并指出其票价
prompt = "\n Give me your age and I'll tell you the fare:"
prompt += "\n(Enter 'quit' when you are finished.) "
age = 0
flag = True
#input函数用来获取用户的输入讯息，参数prompt是提示用户的信息,在while循环中，程序会一直执行，获取用户的输入直到用户的输入为quit，则将falg的值变为False，循环停止执行
while flag:
    message = input(prompt)
    if message == 'quit':
        flag = False
    else:
        age = int(message)
        if age < 3:
            print('The ticket is free')
        elif 3 <= age <= 12:
            print('The fare is 10$')
        elif age > 12:
            print('The fare is 15$')

match语句

match语句类似于Java的Switch语句，当参数与case匹配时执行代码

def get_data(status):
    match status:
        case 404:
            return "Bad Request"
        case 404:
            return "Not Found"
        case 418:
            return "I'm a teapot"
        case 422:
            return "Internal"
        case 500:
            return "Internal Server Error"
        # 通配符_相当于default，可以匹配任意值
        case _:
            return "Something's wrong with the internet"


print(get_data(500))
# Internal Server Error

使用 | （“ or ”）在一个模式中可以组合多个字面值
```
case 401 | 403 | 404:
    return "Not allowed"
```

break和continue语句

#break语句用来直接停止循环，包括for循环和while循环；continue语句则用来跳过当前循环，执行下一次循环
while flag:
    message = input(prompt)
    if message == 'quit':
       break
    else:
        age = int(message)
        if age < 3:
            print('The ticket is free')
        elif 3 <= age <= 12:
            print('The fare is 10$')
        elif age > 12:
            print('The fare is 15$')
#当输入quit的时候，执行break语句，循环就直接停止了不会再去判断条件
#如果是continue语句，则会跳过这次循环，继续执行下一次循环，提示用户输入年龄

注意事项

在使用while循环的时候一定要给出结束循环的条件，避免陷入死循环。

映射与字典

什么是字典？

字典是一个用键值对表示的数据集，由大括号将各个数据键值对括起来，每一个键值对表示一个数据，之间用逗号隔开。
字典的健通常是字符串或数字，也可以是其他任意不可变类型，字典的键是唯一的。
只包含字符串、数字、元组的元组，也可以用作关键字。但如果元组直接或间接地包含了可变对象，就不能用作关键字。

{
    "name":"Jackie Chan",
    "age":"67",
    "job":"actor",
    "films":(2004,"新警察故事")
}

字典有什么用？

字典可以存储基本数据类型，也可以存储列表、元组，甚至是存储字典，而且字典能够很好的表示字典里每个数据的映射关系，键和值的关系是清晰明确的。

字典的常用操作

创建字典：dict()

d1 = {"one":"1","two":2,"three":3}
# 键是类似一个变量名，不需要带双引号
d2 = dict(one=1, two=2, three=3)
d3 = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d4 =  dict([('two', 2), ('one', 1), ('three', 3)])
d5 = dict({'three': 3, 'one': 1, 'two': 2})

# d1=d2=d3=d4=d5
print(type(d1))
#<class 'dict'>

添加或修改字典项


stu_program_language = {
    "Jack": "Java",
    "小明": "Python",
    "小红": "Javascript",
    "李华": "Rust",
}

print(stu_program_language)
# 使用关键字key来添加或修改字典项
# 添加
stu_program_language["张三"] = "C"

print(stu_program_language)

# 修改
stu_program_language["李华"] = "C++"
print(stu_program_language)



#{'Jack': 'Java', '小明': 'Python', '小红': 'Javascript', '李华': 'Rust'}
{'Jack': 'Java', '小明': 'Python', '小红': 'Javascript', '李华': 'Rust', '张三': 'C'}
{'Jack': 'Java', '小明': 'Python', '小红': 'Javascript', '李华': 'C++', '张三': 'C'}

使用[key]或get()获取字典项

# 使用[key]读取
print(stu_program_language["小明"])

# 使用get方法,当get方法找不到键的时候会抛异常，可以加上第二个参数用来指定可选值，当所选键不在字典时返回可选值
lan = stu_program_language.get("李华")

print(lan)

# Python
# Rust

使用keys()获取所有的键

# 使用keys()获取所有的键
print(stu_program_language.keys())
# dict_keys(['Jack', '小明', '小红', '李华'])

print(type(stu_program_language.keys()))
# 类型为 <class 'dict_keys'>

# 可以使用list方法转换为列表 
print(list(stu_program_language.keys()))
# ['Jack', '小明', '小红', '李华']

使用values()获取所有的值

# 使用values()获取所有的值
print(stu_program_language.values())
# dict_values(['Java', 'Python', 'Javascript', 'Rust'])

print(type(stu_program_language.values()))
# <class 'dict_values'>

print(list(stu_program_language.values()))
# ['Java', 'Python', 'Javascript', 'Rust']+

使用items()获取所有的键值对

# 使用items()获取所有的键值对
print(stu_program_language.items())
# dict_items([('Jack', 'Java'), ('小明', 'Python'), ('小红', 'Javascript'), ('李华', 'Rust')])

print(type(stu_program_language.items()))
#<class 'dict_items'>

print(list(stu_program_language.items()))
#[('Jack', 'Java'), ('小明', 'Python'), ('小红', 'Javascript'), ('李华', 'Rust')]
# 每个键值对都以元组的形式返回，使用list可以把这些元组编程一个列表

使用len()获取长度，返回的是键值对的个数
```
print(len(stu_program_language))
# 4
```

使用{** a, ** b}合并字典，是2个字典的浅复制

# 使用{** a, ** b}合并字典
stu_program_language2 = {
    "xiaoming": "C#",
    "lisi": "C",
    "wangwu": "C++"
}

print({**stu_program_language, **stu_program_language2})
# {'Jack': 'Java', '小明': 'Python', '小红': 'Javascript', '李华': 'Rust', 'xiaoming': 'C#', 'lisi': 'C', 'wangwu': 'C++'}

使用update(dict)将dict字典复制到调用的字典里，如果键重复则更新键的值

# 使用update(dict)将dict字典复制到调用的字典里
stu_program_language.update(stu_program_language2)
print(stu_program_language)

# {'Jack': 'Java', '小明': 'Python', '小红': 'Javascript', '李华': 'Rust', 'xiaoming': 'C#', 'lisi': 'C', 'wangwu': 'C++'}

stu_program_language2 = {
    "xiaoming": "C#",
    "李华": "C",
    "wangwu": "C++"
}
stu_program_language.update(stu_program_language2)
print(stu_program_language)

# {'Jack': 'Java', '小明': 'Python', '小红': 'Javascript', '李华': 'C', 'xiaoming': 'C#', 'wangwu': 'C++'}
# 李华的c语言被替换了

使用del按键删除字典项

stu_program_language2 = {
    "xiaoming": "C#",
    "李华": "C",
    "wangwu": "C++"
}

# 使用del按键删除字典项
del stu_program_language2["李华"]
print(stu_program_language2)

# {'xiaoming': 'C#', 'wangwu': 'C++'}

使用 pop() 按键获取字典项并将其删除，和get方法一样也有第二个可选值参数

# 使用 pop() 按键获取字典项并将其删除，如果找不到会抛异常
stu_program_language2.pop("xiaoming")
print(stu_program_language2.pop("xiaoming"))
print(stu_program_language2)

# C#
# {'李华': 'C', 'wangwu': 'C++'}

# 带第二个可选参数
print (stu_program_language2.pop("liuba", "liuba haven't tell us what is his favorite program language"))
#liuba haven't tell us what is his favorite program language

使用 clear() 删除所有字典项，也可以让字典等于{}清空所有字典项
```
stu_program_language2.clear()
print(stu_program_language2)

# {}
```

使用 in 测试键是否存在

print("xiaoming" in stu_program_language2)
print("C#" in stu_program_language2)

# True
# False

使用 copy()复制

dict1 = dict(a="apple",b="boy", c= "cat" , red=[1,2,3,4,5])
dict2 = dict1.copy()
print(dict2)

# {'a': 'apple', 'b': 'boy', 'c': 'cat', 'red': [1, 2, 3, 4, 5]}

使用 deepcopy()复制所有内容，deepcopy是深拷贝，copy是浅拷贝，具体区别可以看

dict1 = dict(a="apple",b="boy", c= "cat" , red=[1,2,3,4,5])
dict2 = dict1.copy()
# deepcopy是由copy模块来调用，传入需要复制的字典
dict3 = copy.deepcopy(dict1)
print(dict2)
print(dict3)

print("------------------------------")
dict1['red'][-1] = 6
print(dict1)
print(dict2)
print(dict3)

# {'a': 'apple', 'b': 'boy', 'c': 'cat', 'red': [1, 2, 3, 4, 6]}
# {'a': 'apple', 'b': 'boy', 'c': 'cat', 'red': [1, 2, 3, 4, 6]}
# {'a': 'apple', 'b': 'boy', 'c': 'cat', 'red': [1, 2, 3, 4, 5]}

# 浅拷贝只是创建了字典的副本为新的引用，字典里面的引用还是指向原来的，所以修改会一起修改
# 而深拷贝则会递归地将在原字典里的对象引用复制为新的引用

比较字典，字典的比较，Python会逐一比较键和值。最初创建字典时采用的顺序并不重要

dict1 = dict(a="apple",b="boy", c= "cat" , red=[1,2,3,4,5])
dict2 = dict1.copy()
dict3 = copy.deepcopy(dict1)
dict1['red'][-1] = 6

print(dict1 == dict2)
print(dict1 == dict3)
print(dict2 == dict3)

# True False False

使用 for 和 in 迭代字典

# 直接迭代字典会返回字典的键
for i in dict1:
    print(i)

# 效果等同于keys获取所有键后迭代
for k in dict1.keys():
    print(k)
# a
# b
# c
# red

# 如果想迭代所有值可以使用values
for v in dict1.values():
    print(v)
# apple
# boy
# cat
# [1, 2, 3, 4, 5]

# 如果想返回键值对可以使用items，可以直接在for循环里定义变量赋值
for k,v in dict1.items():
    print(k,v)
    
# a apple
# b boy
# c cat
# red [1, 2, 3, 4, 5]

字典推导式

# {key_expression : value_expression for expression in iterable}
word = 'letters'
letter_counts = {letter:word.count(letter) for letter in word}
print(letter_counts)

# {'l': 1, 'e': 2, 't': 2, 'r': 1, 's': 1}

# 优化版本，可以避免重复的调用，上面这个例子重复计算了2次e和t的个数
word = 'letters'
# set方法可以把字符串变成一个不可重复的容器，顺序也会发生改变
letter_counts = {letter:word.count(letter) for letter in set(word)}
print(letter_counts)

# {'e': 2, 'l': 1, 'r': 1, 's': 1, 't': 2}

每天都要努力学习的阿凯

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Python基础02——序列&条件循环&字典

序列是一python的一种数据结构，它的成员都是有序排列的，并且可以通过下标偏移量访问到它的一个或几个成员。（正索引从首部访问，副索引从尾部访问）。字符串、元组和列表都是序列，其实是三个继承自序列类的类，他们都可以通过下标索引访问它的成员，都有继承自序列类的共同的方法。序列还是容器（可以包含其他对象的对象）的一种，另一种主要的容器是字典。列表是序列的一种，不同于元组和字符串，列表是可变的，有许多属于列表这个类的独特方法可以用来改变列表。与列表一样，元组也是序列，唯一的差别在于元组是不能修改的。...
复制链接

扫一扫