Python语法基础（字符串 列表 元组 字典 集合）

---

字符串(str)

字符串的创建

创建⼀个字符串，常⽤三种⽅法：

• 单引号
• 双引号
• 三重单引号或者三重双引号

s1 = 'Hello World'
s2 = "Hello World"
s3 = """Hello World"""
s4 = '''Hello World'''

特殊情况

• 字符串中含有双引号

s = 'Hello "World"'

• 多⾏字符串

s = """
诗⼈，就⼀般意义来讲，
通常是指写诗的⼈，但从⽂学概念上讲，
则应是在诗歌（诗词）创作上有⼀定成就的写诗的⼈和诗作家。
诗⼈，通过诗歌创作、吟咏抒发激情，
通过诗歌讴歌祖国的⼤好河⼭，通过诗歌传颂⼈间真善美。
"""

字符串的转义字符

常⻅的转义字符：

• \n

print('hello\nworld')

hello
world

• \t

print('hello\tworld') 

hello    world

• \u

print('\u9ad8\u5706')  # 爬⾍常⻅

unicode编码

小测试：
输⼊⼀个⼈名，返回其unicode编码。

name = input("请输入一个名字")
uc = ""
for w in name:
    uc += r'\u' + hex(ord(w))[2:]  # [2:] 指的是从
print(f'unicode编码等于{uc}')

在Python中，[2:] 是一个切片操作，表示从第2个元素开始，到最后一个元素结束（不包括第2个元素）。具体来说，它将返回一个包含原始列表（或字符串、元组等）中第2个元素之后的所有元素的子列表。

注意：r'\u' 是原始字符串（raw string）的表示方式，它告诉Python解释器该字符串中的所有字符都应该被原封不动地按照字面意义解释，不应该进行转义。这意味着在原始字符串中，反斜杠（\）被视为字面字符，而不是转义字符的引导。

字符串的运算符

操作符	描述	实例(a = “Hello” b = “Python”)
+	字符串连接	a + b 输出结果： HelloPython
*	重复输出字符串	a * 2 输出结果：HelloHello
[]	通过索引获取字符串中字符	a[1] 输出结果 e
[ : ]	截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。	a[1:4] 输出结果 ell
in	成员运算符 - 如果字符串中包含给定的字符返回 True	‘H’ in a 输出结果 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	‘M’ not in a 输出结果 True
r/R	原始字符串 - 所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	print( r’\n’ )

a = "Python3.0"
b = "Python"
print("a + b 输出结果：", a + b) 
print("a * 2 输出结果：", a * 2) 
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
if( "H" in a) : 
    print("H 在变量 a 中") 
else : 
    print("H 不在变量 a 中") 
if( "M" not in a) : 
    print("M 不在变量 a 中") 
else :
    print("M 在变量 a 中")
print (r'\n')
print (R'\n')

字符串常用方法

常⽤场景：

1. 求字符串⻓度
2. 去掉多余空格
3. 是否包括某个⼦串
4. 分割字符串
5. 合并字符串
6. 替换字符串
7. 统计字符串出现的次数

求字符串长度

len(string)

s = "人生苦短，何以解忧"
print(len(s))

去掉多余空格

strip() 方法用于删除字符串左右两个的空格和特殊字符
str.strip([chars])
str 表示原字符串，[chars] 用来指定要删除的字符，可以同时指定多个，如果不手动指定，则默认会删除空格以及制表符、回车符、换行符等特殊字符。

s = '    ' + "Hello - World" + "      "
print(s.strip())

# --输出
# Hello - World     

是否包含某子串

find() 方法用于检索字符串中是否包含目标字符串，如果包含，则返回第一次出现该字符串的索引；反之，则返回 -1。index() 方法也同理，不同之处在于，当指定的字符串不存在时，index() 方法会抛出异常。

str.find(sub[,start[,end]])
str.index(sub[,start[,end]])

1. str：表示原字符串；
2. sub：表示要检索的目标字符串；
3. start：表示开始检索的起始位置。如果不指定，则默认从头开始检索；
4. end：表示结束检索的结束位置。如果不指定，则默认一直检索到结尾。

s = "Hello World"
print(s.find("World"))
print(s.index("World"))

# --输出
# 6
# 6

分割字符串

str.split(sep, maxsplit)

1. str：表示要进行分割的字符串；
2. sep：用于指定分隔符，可以包含多个字符。此参数默认为 None，表示所有空字符，包括空格、换行符 “\n”、制表符 “\t” 等
3. maxsplit：可选参数，用于指定分割的次数，最后列表中子串的个数最多为 maxsplit + 1。如果不指定或者指定为 -1，则表示分割次数没有限制。

需要注意的是，在未指定 sep 参数时，split() 方法默认采用空字符进行分割，但当字符串中有连续的空格或其他空字符时，都会被视为一个分隔符对字符串进行分割。

s = '    ' + "Hello - World" + "      "
print(s)
t = s.split()
print(t)

# --输出
#      Hello - World      
# ['Hello', '-', 'World']

合并字符串

join() 方法也是非常重要的字符串方法，它是 split() 方法的逆方法，用来将列表（或元组）中包含的多个字符串连接成一个字符串。

newstr = str.join(iterable)

1. newstr：表示合并后生成的新字符串；
2. str：用于指定合并时的分隔符；
3. iterable：做合并操作的源字符串数据，允许以列表、元组等形式提供。

s1 = "every"
s2 = "night"
s3 = "day"
s = ' '.join([s1, s2, s1, s3])
print(s)

# --输出
# every night every day

替换字符串

string.replace( old, new, count )

1. old ：（必选，字符串类型）被替换的字符串
2. new ：（必选，字符串类型）替换后的字符串
3. count ：（可选，整型）替换的次数

str1 = 'hello hello hello hello world'
str2 = str1.replace('hello', 'world')
print(str2)

# --输出
# world world world world world

统计统计字符串出现的次数

str.count(sub[,start[,end]])

1. str：表示原字符串；
2. sub：表示要检索的字符串；
3. start：指定检索的起始位置，也就是从什么位置开始检测。如果不指定，默认从头开始检索；
4. end：指定检索的终止位置，如果不指定，则表示一直检索到结尾。

s1 = "every"
s2 = "night"
s3 = "day"
s = ' '.join([s1, s2, s1, s3])
cnt = s.count(' ', 2)
print(cnt)

练习：判断字符串是否为回文串

s = input()
left, right = 0, len(s) - 1
flag = True
while left < right:
    if s[left] != s[right]:
        flag = False
        break
    left += 1
    right -= 1
print("Yes") if flag else print("No")

列表(list)

列表特点：

• 列表内能包括多个元素
• 多个元素的类型可以各不相同
• 列表在内存中是紧邻存储

列表的创建

三种列表创建的常用方法：

• []
• list函数
• range函数

1. []
使用空方括号[]可以直接创建一个空列表，例如：

a = []

2. list函数
可以使用内置的list函数,将其他数据类型转换成列表，例如：

b = list("hello")  # ['h', 'e', 'l', 'l', 'o']

c = list((1,2,3))  # [1, 2, 3]

3. range函数

range可以生成一个整数序列，转换成list后就是一个列表，例如：

d = list(range(5))  # [0, 1, 2, 3, 4]

列表常用方法

方法	作用
列表.append(元素)	向列表中追加一个元素
列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部
列表.insert(下标, 元素)	在指定下标处，插入指定的元素
del 列表[下标]	删除列表指定下标元素
列表.pop(下标)	删除列表指定下标元素(无下标则删除最后一个元素)，返回列表中的最后一个元素
列表.remove(元素)	移除列表中第一个匹配到的指定元素
列表.clear()	清空列表
列表.count(元素)	统计此元素在列表中出现的次数
列表.index(元素)	查找指定元素在列表的下标，找不到报错ValueError
len(列表)	统计容器内有多少元素

遍历列表

• 与 range 结合
• in 直接拿元素

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

# 与 range 结合
for i in range(len(a)):
    print(a[i], end=' ')

print()
# in 直接拿元素
for e in a:
    print(e, end=' ')

在 Python 中，for e in a 循环中，e 并不是对列表 a 中元素的引用，而是对元素的拷贝。

当使用 for e in a 进行迭代时，e 是列表 a 中的元素的拷贝，并不是原始元素的引用。这意味着对 e 所做的修改不会影响列表 a 中对应的元素。

列表生成式

列表生成式（List Comprehension）是一种简洁的语法，用于创建新的列表。它允许在单个语句中使用迭代、条件和表达式来定义列表的内容。

new_list = [expression for item in iterable if condition]

• expression 是生成新列表元素的表达式。
• item 是迭代过程中的临时变量，表示可迭代对象中的每个元素。
• iterable 是可迭代对象，例如列表、字符串、元组等。
• condition 是可选的条件表达式，用于筛选元素。

创建一个包含平方数的列表

squares = [x**2 for x in range(1, 6)]
print(squares)  # 输出: [1, 4, 9, 16, 25]

过滤出偶数的列表

number = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
number_even = [x for x in number if not x & 1]
print(number_even)  # 输出: [2, 4, 6, 8, 10] 

处理字符串列表并转换为大写

words = ['hello', 'world', 'python']
upper_words = [word.upper() for word in words]
print(upper_words)  # 输出: ['HELLO', 'WORLD', 'PYTHON']

练习：冰雹序列

背景知识：
数学中有⼀系列数字，有时被称为雹⽯序列。
考拉兹猜想（英语：Collatz conjecture），⼜称为奇偶归⼀猜想、冰雹猜想。
是指对于每⼀个正整数，如果它是奇数，则对它乘3再加1，如果它是偶数，则对它除以2，如此循
环，最终都能够得到1。

number = int(input("请输入一个数字:> "))
a = [number]
while number > 1:
    if number & 1:
        number = number * 3 + 1
    else:
        number //= 2
    a.append(number)
print(a)

# 请输入一个数字:> 13
# [13, 40, 20, 10, 5, 16, 8, 4, 2, 1]

元组(tuple)

元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

元组的创建

1.使用逗号创建

a = 1, 2, 3, 4, 5

2.使用圆括号创建

a = (1, 2, 3, 4, 5)

3.使用tuple()构造函数

a = tuple([1, 2, 3, 4, 5])

元组的遍历

a = tuple(['2021-04-01', '开盘', 3010])
print(a)
print(a[0])
print(a[1:3])

# ('2021-04-01', '开盘', 3010)
# 2021-04-01
# ('开盘', 3010)

元组的拼接

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz') 
# 创建一个新的元组将两个元组组合
tup3 = tup1 + tup2 
print (tup3)

# (12, 34.56, 'abc', 'xyz')

元组的整个删除

tup = ('一', '二', '三', '四','五')
print (tup)
del tup 
print ("删除后的元组 tup : ") 
print (tup)

字典(dict)

在Python中，字典（Dictionary）是一种可变的、无序的数据结构，用于存储键-值（key-value）对。字典通过键来访问值，而不是通过索引。字典中的键必须是唯一的，而值可以是任何有效的Python对象。字典使用花括号 {} 来创建，每个键值对之间使用冒号 : 分隔。

示例：

my_dict = {"name": "John", "age": 30, "city": "New York"}

字典的创建

花括号 {} 创建字典

my_dict = {'Name': 'ZZZ', 'Age': 178, 'Class': 'First'}
another_dict = {}

dict() 构造函数创建字典

1. 创建空字典

my = dict()

2. 使用键值对列表创建字典

pairs = [("name", "John"), ("age", 30), ("city", "New York")]
my_dict = dict(pairs)

这将使用键值对列表 pairs 创建一个字典对象 my_dict。列表中的每个元素都是一个包含键和值的元组。

3. 使用关键字参数创建字典

my_dict = dict(name="John", age=30, city="New York")

这将使用关键字参数来指定键值对，创建一个字典对象 my_dict。每个关键字都表示一个键，对应的值则由关键字参数的值确定。

4. 使用可迭代对象创建字典

keys = ["name", "age", "city"]
values = ["John", 30, "New York"]
my_dict = dict(zip(keys, values))

这将使用 zip() 函数将两个可迭代对象 keys 和 values 组合成一个键值对列表，并使用该列表创建一个字典对象 my_dict。

遍历字典

• 获取字典的键或值或键值对
• 通过键获取值
• 通过键值对获取值

# 示例字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 获取字典的键
for key in my_dict.keys():
    print(key, end=' ')
print()
# a b c

# 获取字典的值
for value in my_dict.values():
    print(value, end=' ')
print()
# 1 2 3

# 获取字典的键值对
for key, value in my_dict.items():
    print(key, value)
# a 1
# b 2
# c 3

# 通过键获取值
value = my_dict['a']
print(value)
# 1

# 通过键值对获取值
for key, value in my_dict.items():
    if key == 'a':
        print(value)
# 1

访问字典

• 直接访问

如果用字典里没有的键访问数据，会输出错误。

dict[key]

• 安全访问

返回指定键的值，如果键不存在则返回默认值。

dict.get(key, default=None)

• 检查指定键是否存在于字典中，返回True或False。

key in dict

更新字典

• 修改原有键

如果键不存在，则会创建新的键值对；如果键已经存在，那么对应的值会被更新。

dict[key] = new_valve

• 添加键值对

如果 dict.update() 方法中传递的键在目标字典中已经存在，那么该键对应的值会被更新为新的值。如果键不存在，会将新的键值对添加到字典中。

dict.update(other_dict)

示例：

my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}

# 更新已存在的键
my_dict.update({'name': 'Jane'})

# 添加新的键值对
my_dict.update({'gender': 'Female'})

print(my_dict)
# {'name': 'Jane', 'age': 12, 'city': 'New York', 'gender': 'Female'}

删除字典键值对

• pop某个键值对

删除指定键的键值对，并返回该键对应的值。如果键不存在，则返回默认值。

dict.pop(key, default=None)

• del某个键值对

del dict[key]

练习：统计输入中文文章的汉字和出现次数

filter_list = [',', '，', '.', '。', '"', '“', '！', ' ', '”', '!', '\n']
passage = """
我与⽗亲不相⻅已⼆年余了，我最不能忘记的是他的背影。那年冬天，祖⺟死了，⽗亲的差
使也交卸了，正是祸不单⾏的⽇⼦，我从北京到徐州，打算跟着⽗亲奔丧回家。到徐州⻅着⽗
亲，看⻅满院狼藉的东⻄，⼜想起祖⺟，不禁簌簌地流下眼泪。⽗亲说，“事已如此，不必难过，
好在天⽆绝⼈之路!”
"""
result_dict = {}
for word in passage:
    if word in filter_list:
        continue
    if word not in result_dict:
        result_dict[word] = 1
    else:
        result_dict[word] += 1
print(result_dict)

max_ooc = 0
max_word = ""
for k, v in result_dict.items():
    if v > max_ooc:
        max_ooc, max_word = v, k
print(f"出现次数最多的字是[{max_word}]，最大出现次数为{max_ooc}")

输出结果：

{'我': 3, '与': 1, '⽗': 5, '亲': 5, '不': 5, '相': 1, '⻅': 3, '已': 2, '⼆': 1, '年': 2, '余': 1, '了': 3, '最': 1, '能': 1, '忘': 1, '记': 1, '的': 5, '是': 2, '他': 1, '背': 1, '影': 1, '那': 1, '冬': 1, '天': 2, '祖': 2, '⺟': 2, '死': 1, '差': 1, '使': 1, '也': 1, '交': 1, '卸': 1, '正': 1, '祸': 1, '单': 1, '⾏': 1, '⽇': 1, '⼦': 1, '从': 1, '北': 1, '京': 1, '到': 2, '徐': 2, '州': 2, '打': 1, '算': 1, '跟': 1, '着': 2, '奔': 1, '丧': 1, '回': 1, '家': 1, '看': 1, '满': 1, '院': 1, '狼': 1, '藉': 1, '东': 1, '⻄': 1, '⼜': 1, '想': 1, '起': 1, '禁': 1, '簌': 2, '地': 1, '流': 1, '下': 1, '眼': 1, '泪': 1, '说': 1, '事': 1, '如': 1, '此': 1, '必': 1, '难': 1, '过': 1, '好': 1, '在': 1, '⽆': 1, '绝': 1, '⼈': 1, '之': 1, '路': 1}
出现次数最多的字是[⽗]，最大出现次数为5

集合(set)

set，是⼀种集合，与字典相似，也是使⽤哈希函数，将key映射到哈希表的⼀种数据结构。只不过，不像字典那样key上绑定⼀个value，set集合仅仅有key。

无序性

set和字典都是经映射函数处理后，存放在散列表中，且出现在散列表中的位置⼀定是随机的，是没有顺序的。所以我们不能采⽤下标索引的⽅法，访问其中的每个元素，之前我们学过列表、元组是可以使⽤下标索引访问每个元素。

set内元素不会重复

my_list = [3,1,2,2,3,3,3]
unique = set(my_list)
print(unique)

# {1, 2, 3}

set内增删元素

set.add(element)：向集合中添加一个元素。
set.update(*others)：向集合中添加多个元素，可以传入其他集合、列表或元组。
set.remove(element)：从集合中移除指定的元素，如果元素不存在则会引发KeyError错误。
set.discard(element)：从集合中移除指定的元素，如果元素不存在则不会引发错误。
set.pop()：随机从集合中移除并返回一个元素。
set.clear()：清空集合中的所有元素。

set之间的操作

在Python中，你可以使用各种集合操作来对集合进行交集、并集、差集和对称差等操作。下面是一些常见的集合操作：

1. 交集：使用 set.intersection(other_set) 或 set1 & set2 来获取两个集合的交集。

2. 并集：使用 set.union(other_set) 或 set1 | set2 来获取两个集合的并集。

3. 差集：使用 set.difference(other_set) 或 set1 - set2 来获取两个集合的差集（在 set1 中但不在 set2 中的元素）。

4. 对称差：使用 set.symmetric_difference(other_set) 或 set1 ^ set2 来获取两个集合的对称差（在 set1 或 set2 中，但不同时在两者中的元素）。

5. 子集：使用 set.issubset(other_set) 或 set1 <= set2 来检查 set1 是否是 set2 的子集。

6. 超集：使用 set.issuperset(other_set) 或 set1 >= set2 来检查 set1 是否是 set2 的超集。

7. 不相交集：使用 set.isdisjoint(other_set) 来检查两个集合是否没有共同的元素。