Python入门笔记：语言基础篇（字符串与“数组”）

slogan： 我学编程就是为了赚钱，后来发现它不只是能赚钱…

---

1.字符串

所谓字符串，就是由零个或多个字符组成的有限序列。在Python中，单个或多个字符用单引号或者双引号包围起来，就可以表示一个字符串。

s1 = 'hello, world!'
s2 = "hello, world!"
# 以三个双引号或单引号开头的字符串可以折行
s3 = """
hello, 
world!
"""
print(s1, s2, s3, end='')

1.1 字符串的转义

在字符串中使用\（反斜杠）来表示转义，也就是说\后面的字符不再是它原来的意义，例如：\n表示换行；\t表示制表符。所以如果想在字符串中表示'要写成\'，同理想表示\要写成\\。

在\后面还可以跟一个八进制或者十六进制数来表示字符，例如\141和\x61都代表小写字母a，前者是八进制的表示法，后者是十六进制的表示法。也可以在\后面跟Unicode字符编码来表示字符。

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，例如：\o12代表换行
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

如果不希望字符串中的\表示转义，我们可以通过在字符串的最前面加上字母r来加以说明。

s1 = r'\'hello, world!\''
s2 = r'\n\\hello, world!\\\n'
print(s1, s2, end='')

1.2 字符串的运算

Python为字符串类型提供了非常丰富的运算符，我们可以使用+运算符来实现字符串的拼接，可以使用*运算符来重复一个字符串的内容，可以使用in和not in来判断一个字符串是否包含另外一个字符串（成员运算），我们也可以用[]和[:]运算符从字符串取出某个字符或某些字符（切片运算），代码如下所示。

s1 = 'hello ' * 3
print(s1) # hello hello hello 
s2 = 'world'
s1 += s2
print(s1) # hello hello hello world
print('ll' in s1) # True
print('good' in s1) # False
str2 = 'abc123456'
# 从字符串中取出指定位置的字符(下标运算)
print(str2[2]) # c
# 字符串切片(从指定的开始索引到指定的结束索引)
print(str2[2:5]) # c12
print(str2[2:]) # c123456
print(str2[2::2]) # c246
print(str2[::2]) # ac246
print(str2[::-1]) # 654321cba
print(str2[-3:-1]) # 45

• 字符串操作符总结

操作符	描述
+	字符串连接
*	重复输出字符串
[]	通过索引获取字符串中字符
[ : ]	截取字符串中的一部分
in	成员运算符 - 如果字符串中包含给定的字符返回 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
%	格式字符串

1.3 用%来格式化字符串

a, b = 5, 10
print('%d * %d = %d' % (a, b, a * b))

格式化字符串还有更为简洁的书写方式，就是在字符串前加上字母f，我们可以使用下面的语法糖来简化上面的代码。

a, b = 5, 10
print(f'{a} * {b} = {a * b}')

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%F 和 %E 的简写
%p	用十六进制数格式化变量的地址

1.4 用内置方法处理字符串

在Python中，我们还可以通过一系列内置方法来完成对字符串的处理，代码如下所示。

str1 = 'hello, world!'
# 通过内置函数len计算字符串的长度
print(len(str1)) # 13
# 获得字符串首字母大写的拷贝
print(str1.capitalize()) # Hello, world!
# 获得字符串每个单词首字母大写的拷贝
print(str1.title()) # Hello, World!
# 获得字符串变大写后的拷贝
print(str1.upper()) # HELLO, WORLD!
# 从字符串中查找子串所在位置
print(str1.find('or')) # 8
print(str1.find('shit')) # -1
# 与find类似但找不到子串时会引发异常
# print(str1.index('or'))
# print(str1.index('shit'))
# 检查字符串是否以指定的字符串开头
print(str1.startswith('He')) # False
print(str1.startswith('hel')) # True
# 检查字符串是否以指定的字符串结尾
print(str1.endswith('!')) # True
# 将字符串以指定的宽度居中并在两侧填充指定的字符
print(str1.center(50, '*'))
# 将字符串以指定的宽度靠右放置左侧填充指定的字符
print(str1.rjust(50, ' '))
str2 = 'abc123456'
# 检查字符串是否由数字构成
print(str2.isdigit())  # False
# 检查字符串是否以字母构成
print(str2.isalpha())  # False
# 检查字符串是否以数字和字母构成
print(str2.isalnum())  # True
str3 = ' 110 '
print(str3)
# 获得字符串修剪左右两侧空格之后的拷贝
print(str3.strip())

---

2. Python里的“数组”

除了字符串，Python还内置了多种类型的数据结构（又称序列），这些序列类似于C、Java等这些编程语言里的数组，可以在程序中保存和操作数据，绝大多数时候可以利用现有的数据结构来实现，最常用的包括列表、元组、集合和字典。

2.1 列表 List

• 如何定义列表、如何遍历列表以及列表的下标运算。

list1 = [1, 3, 5, 7, 100]
print(list1) # [1, 3, 5, 7, 100]
# 乘号表示列表元素的重复

list2 = ['hello'] * 3
print(list2) # ['hello', 'hello', 'hello']
# 计算列表长度(元素个数)

print(len(list1)) # 5
# 下标(索引)运算

print(list1[0]) # 1
print(list1[4]) # 100
print(list1[5])  # IndexError: list index out of range
print(list1[-1]) # 100
print(list1[-3]) # 5

list1[2] = 300
print(list1) # [1, 3, 300, 7, 100]

# 通过循环用下标遍历列表元素
for index in range(len(list1)):
    print(list1[index])
    
# 通过for循环遍历列表元素
for elem in list1:
    print(elem)
    
# 通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值
for index, elem in enumerate(list1):
    print(index, elem)

• 如何从列表中添加和移除元素。

list1 = [1, 3, 5, 7, 100]
list1.append(200)	# 添加元素
list1.insert(1, 400)	# 合并两个列表

list1.extend([1000, 2000])
list1 += [1000, 2000]
print(list1) 
# [1, 400, 3, 5, 7, 100, 200, 1000, 2000]
print(len(list1)) # 9

# 先通过成员运算判断元素是否在列表中，如果存在就删除该元素
if 3 in list1:
	list1.remove(3)
if 1234 in list1:
    list1.remove(1234)
print(list1) 
# [1, 400, 5, 7, 100, 200, 1000, 2000]

# 从指定的位置删除元素
list1.pop(0)
list1.pop(len(list1) - 1)
print(list1) # [400, 5, 7, 100, 200, 1000]

# 清空列表元素
list1.clear()
print(list1) # []

• 如何对列表进行切片操作

和字符串一样，列表也可以做切片（截取与拼接）操作，通过切片操作我们可以实现对列表的复制或者将列表中的一部分取出来创建出新的列表，代码如下所示。

fruits = ['grape', 'apple', 'strawberry', 'waxberry']
fruits += ['pitaya', 'pear', 'mango']

# 列表切片
fruits2 = fruits[1:4]
print(fruits2) # apple strawberry waxberry

# 可以通过完整切片操作来复制列表
fruits3 = fruits[:]
print(fruits3) 
# ['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
fruits4 = fruits[-3:-1]
print(fruits4) # ['pitaya', 'pear']

# 可以通过反向切片操作来获得倒转后的列表的拷贝
fruits5 = fruits[::-1]
print(fruits5) 
# ['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']

• 如何对列表进行排序操作

list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
list2 = sorted(list1)	# sorted函数返回列表排序后的拷贝不会修改传入的列表
list3 = sorted(list1, reverse=True)

# 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
list4 = sorted(list1, key=len)
print(list1)
print(list2)
print(list3)
print(list4)

# 给列表对象发出排序消息直接在列表对象上进行排序
list1.sort(reverse=True)
print(list1)

• 列表内置方法

方法	描述
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)	将对象插入列表
list.pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reverse()	反向列表中元素
list.sort( key=None, reverse=False)	对原列表进行排序
list.clear()	清空列表
list.copy()	复制列表

2.2 元组 Tuple

Python中的元组与列表类似也是一种容器数据类型，可以用一个变量（对象）来存储多个数据，不同之处在于元组的元素不能修改。元组使用小括号，而列表使用方括号。

• 如何定义和使用元组。

# 定义元组
t = ('小明', 18, True, '男')
print(t)

# 获取元组中的元素
print(t[0])	#小明
print(t[3])	#True

# 遍历元组中的值
for member in t:
    print(member)	#小明 18 True 男

# 重新给元组赋值
t[0] = '小红'
t[3] = '女'
# 变量t重新引用了新的元组原来的元组将被垃圾回收
t = ('小红', 20, True, '女')
print(t)

# 将元组转换成列表
person = list(t)
print(person)

# 列表是可以修改它的元素的
person[0] = '李小龙'
person[1] = 25
print(person)

# 将列表转换成元组
fruits_list = ['apple', 'banana', 'orange']
fruits_tuple = tuple(fruits_list)
print(fruits_tuple)

• 元祖内置方法

方法	描述
len(tuple)	计算元组元素个数。
max(tuple)	返回元组中元素最大值。
min(tuple)	返回元组中元素最小值。
tuple(iterable)	将可迭代系列转换为元组。

2.3 集合 Set

Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。

• 如何创建和使用集合。

# 使用 {} 大括号来创建集合
set1 = {1, 2, 3, 3, 3, 2}
print(set1)

# 使用 set() 方法创建集合
set2 = set((1, 2, 3, 3, 2, 1))
set3 = set(range(1, 10))
print(set2, set3)

# 对集合进行操作
set1.add(4)		#使用add()添加元素
set2.update([11, 12])	#使用update()修改元素
if 4 in set2:
    set2.remove(4)	#使用remove()删除元素
print(set1, set2)
print(set3.pop())	#使用pop()随机删除一个元素
print(set3)

• 集合内置方法

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

2.4 字典 Dict

字典是另一种可变容器模型，Python中的字典跟我们生活中使用的字典是一样的，它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。

• 如何定义和使用字典。

# 使用 {} 大括号创建字典， 格式为：d = {key1 : value1, key2 : value2 }
dict0 = { 'Alice': '2341', 'Beth': '9102', 'Cecil': '3258' }
dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }
print(dict1)

# 使用 dict() 函数创建字典
items1 = dict(one=1, two=2, three=3, four=4)
items2 = dict(zip(['a', 'b', 'c'], '123'))	# 通过zip函数将两个序列压成字典
print(items1, items2)

# 通过键可以获取字典中对应的值
dict = {'Name': 'Runoob', 'Age': 7, 'Class': '1'}
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

# 对字典中所有键值对进行遍历
for key in dict:
    print(f'{key}: {dict[key]}')
    
# 更新字典中的元素
dict['Name'] = 'Tom'
dict['Age'] = 10
dict.update(Class='2')
print(dict)

# get方法也是通过键获取对应的值但是可以设置默认值
print(dict.get('Age', 10))

# 删除字典中的元素
print(dict.pop('Class', 2))

# 清空字典
dict.clear()
print(dict)

• 字典键的特性

1. 不允许同一个键出现两次。创建时如果同一个键被赋值两次，只保留后一个值，即新的赋值会覆盖旧值。
2. 键必须不可变，所以可以用数字，字符串或元组充当，而不能使用列表。

• 字典内置函数

函数	描述
len(dict)	计算字典元素个数，即键的总数。
str(dict)	输出字典，以可打印的字符串表示。
type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型。

• 字典内置方法

方法	描述
radiansdict.clear()	删除字典内所有元素
radiansdict.copy()	返回一个字典的浅复制
radiansdict.fromkeys()	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
radiansdict.get(key, default=None)	返回指定键的值，如果值不在字典中返回default值
key in dict	如果键在字典dict里返回true，否则返回false
radiansdict.items()	以列表返回可遍历的(键, 值) 元组数组
radiansdict.keys()	返回一个迭代器，可以使用 list() 来转换为列表
radiansdict.setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
radiansdict.update(dict2)	把字典dict2的键/值对更新到dict里
radiansdict.values()	返回一个迭代器，可以使用 list() 来转换为列表
pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem()	随机返回并删除字典中的最后一对键和值。