序列
什么是序列?
- 序列是一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}