Python学习笔记5——数据类型(进阶篇)

使用字符串

1 s1 = 'hello, world!'
2 s2 = "hello, world!"
3 # Python 中单引号、双引号和三引号的字符串是一模一样的，这样方便你在字符串中，内嵌带引号的字符串。
4 s3 = """
5 hello, 
6 world!
7 """
8 print(s1, s2, s3, end='')

可以在字符串中使用\（反斜杠）来表示转义，也就是说\后面的字符不再是它原来的意义，例如：\n不是代表反斜杠和字符n，而是表示换行；而\t也不是代表反斜杠和字符t，而是表示制表符。所以如果想在字符串中表示'要写成\'，同理想表示\要写成\\。可以运行下面的代码看看会输出什么。

1 s1 = '\'hello, world!\''
2 s2 = '\n\\hello, world!\\\n'
3 print(s1, s2, end='')

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

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

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

 1 str1 = 'hello, world!'
 2 # 通过内置函数len计算字符串的长度
 3 print(len(str1)) # 13
 4 # 获得字符串首字母大写的拷贝
 5 print(str1.capitalize()) # Hello, world!
 6 # 获得字符串每个单词首字母大写的拷贝
 7 print(str1.title()) # Hello, World!
 8 # 获得字符串变大写后的拷贝
 9 print(str1.upper()) # HELLO, WORLD!
10 # 从字符串中查找子串所在位置
11 print(str1.find('or')) # 8
12 print(str1.find('shit')) # -1
13 # 与find类似但找不到子串时会引发异常
14 # print(str1.index('or'))
15 # print(str1.index('shit'))
16 # 检查字符串是否以指定的字符串开头
17 print(str1.startswith('He')) # False
18 print(str1.startswith('hel')) # True
19 # 检查字符串是否以指定的字符串结尾
20 print(str1.endswith('!')) # True
21 # 将字符串以指定的宽度居中并在两侧填充指定的字符
22 print(str1.center(50, '*'))
23 # 将字符串以指定的宽度靠右放置左侧填充指定的字符
24 print(str1.rjust(50, ' '))
25 str2 = 'abc123456'
26 # 检查字符串是否由数字构成
27 print(str2.isdigit())  # False
28 # 检查字符串是否以字母构成
29 print(str2.isalpha())  # False
30 # 检查字符串是否以数字和字母构成
31 print(str2.isalnum())  # True
32 str3 = '  jackfrued@126.com '
33 print(str3)
34 # 获得字符串修剪左右两侧空格之后的拷贝
35 print(str3.strip())

我们也可以用字符串提供的方法来完成字符串的格式，代码如下所示。

1 a, b = 5, 10
2 print('{0} * {1} = {2}'.format(a, b, a * b))

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

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

除了字符串，Python还内置了多种类型的数据结构，如果要在程序中保存和操作数据，绝大多数时候可以利用现有的数据结构来实现，最常用的包括列表、元组、集合和字典。

使用列表

下面的代码演示了如何定义列表、如何遍历列表以及列表的下标运算。

 1 list1 = [1, 3, 5, 7, 100]
 2 print(list1) # [1, 3, 5, 7, 100]
 3 # 乘号表示列表元素的重复
 4 list2 = ['hello'] * 3
 5 print(list2) # ['hello', 'hello', 'hello']
 6 # 计算列表长度(元素个数)
 7 print(len(list1)) # 5
 8 # 下标(索引)运算
 9 print(list1[0]) # 1
10 print(list1[4]) # 100
11 # print(list1[5])  # IndexError: list index out of range
12 print(list1[-1]) # 100
13 print(list1[-3]) # 5
14 list1[2] = 300
15 print(list1) # [1, 3, 300, 7, 100]
16 # 通过循环用下标遍历列表元素
17 for index in range(len(list1)):
18     print(list1[index])
19 # 通过for循环遍历列表元素
20 for elem in list1:
21     print(elem)
22 # 通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值
23 for index, elem in enumerate(list1):
24     print(index, elem)

下面的代码演示了如何向列表中添加元素以及如何从列表中移除元素。

 1 list1 = [1, 3, 5, 7, 100]
 2 # 添加元素
 3 list1.append(200)
 4 list1.insert(1, 400)
 5 # 合并两个列表
 6 # list1.extend([1000, 2000])
 7 list1 += [1000, 2000]
 8 print(list1) # [1, 400, 3, 5, 7, 100, 200, 1000, 2000]
 9 print(len(list1)) # 9
10 # 先通过成员运算判断元素是否在列表中，如果存在就删除该元素
11 if 3 in list1:
12     list1.remove(3)
13 if 1234 in list1:
14     list1.remove(1234)
15 print(list1) # [1, 400, 5, 7, 100, 200, 1000, 2000]
16 # 从指定的位置删除元素
17 list1.pop(0)
18 list1.pop(len(list1) - 1)
19 print(list1) # [400, 5, 7, 100, 200, 1000]
20 # 清空列表元素
21 list1.clear()
22 print(list1) # []

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

 1 fruits = ['grape', 'apple', 'strawberry', 'waxberry']
 2 fruits += ['pitaya', 'pear', 'mango']
 3 # 列表切片
 4 fruits2 = fruits[1:4]
 5 print(fruits2) # apple strawberry waxberry
 6 # 可以通过完整切片操作来复制列表
 7 fruits3 = fruits[:]
 8 print(fruits3) # ['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
 9 fruits4 = fruits[-3:-1]
10 print(fruits4) # ['pitaya', 'pear']
11 # 可以通过反向切片操作来获得倒转后的列表的拷贝
12 fruits5 = fruits[::-1]
13 print(fruits5) # ['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']

下面的代码实现了对列表的排序操作。

 1 list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
 2 list2 = sorted(list1)
 3 # sorted函数返回列表排序后的拷贝不会修改传入的列表
 4 # 函数的设计就应该像sorted函数一样尽可能不产生副作用
 5 list3 = sorted(list1, reverse=True)
 6 # 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
 7 list4 = sorted(list1, key=len)
 8 print(list1)
 9 print(list2)
10 print(list3)
11 print(list4)
12 # 给列表对象发出排序消息直接在列表对象上进行排序
13 list1.sort(reverse=True)
14 print(list1)

生成式和生成器

具体语法可以参考《Python生成式和生成器》，简述生成式语法如下：

 1 a = [x * x for x in range(10) if x*x%2 ==0]
 2 
 3 """
 4 1、for循环取出range(10)从0到9的数字
 5 2、if语句判断x*x是否为偶数，如果是则保留存在新的列表中
 6 3、把所有符合x*x是偶数的元素都放到新的列表中返回
 7 """
 8 
 9 print(type(a))
10 print(a)
11 
12 """
13 运行结果：
14 <type 'list'>
15 [0, 4, 16, 36, 64]
16 """

我们还可以使用列表的生成式语法来创建列表，代码如下所示。

 1 f = [x for x in range(1, 10)]
 2 print(f)
 3 f = [x + y for x in 'ABCDE' for y in '1234567']
 4 print(f)
 5 # 用列表的生成表达式语法创建列表容器
 6 # 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
 7 f = [x ** 2 for x in range(1, 1000)]
 8 print(sys.getsizeof(f))  # 查看对象占用内存的字节数
 9 print(f)
10 # 请注意下面的代码创建的不是一个列表而是一个生成器对象
11 # 通过生成器可以获取到数据但它不占用额外的空间存储数据
12 # 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)
13 f = (x ** 2 for x in range(1, 1000))
14 print(sys.getsizeof(f))  # 相比生成式生成器不占用存储数据的空间
15 print(f)
16 for val in f:
17     print(val)

除了上面提到的生成器语法，Python中还有另外一种定义生成器的方式，就是通过yield关键字将一个普通函数改造成生成器函数。下面的代码演示了如何实现一个生成斐波拉切数列的生成器。所谓斐波拉切数列可以通过下面递归的方法来进行定义：

$${\displaystyle F_{0}=0}$$

$${\displaystyle F_{1}=1}$$

$${\displaystyle F_{n}=F_{n-1}+F_{n-2}}({n}\geq{2})$$

 1 def fib(n):
 2     a, b = 0, 1
 3     for _ in range(n):
 4         a, b = b, a + b
 5         yield a
 6 
 7 # 生成器函数会使用yeild关键字返回一个a的generator，可以用for循环输出
 8 def main():
 9     for val in fib(20):
10         print(val)
11  
12 if __name__ == '__main__':
13     main()

使用元组

Python中的元组与列表类似也是一种容器数据类型，可以用一个变量（对象）来存储多个数据，不同之处在于元组的元素不能修改，在前面的代码中我们已经不止一次使用过元组了。顾名思义，我们把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。下面的代码演示了如何定义和使用元组。

 1 # 定义元组
 2 t = ('洛阳铲', 18, True, '洛阳')
 3 print(t)
 4 # 获取元组中的元素
 5 print(t[0])
 6 print(t[3])
 7 # 遍历元组中的值
 8 for member in t:
 9     print(member)
10 # 重新给元组赋值
11 # t[0] = '王大锤'  # TypeError
12 # 变量t重新引用了新的元组原来的元组将被垃圾回收
13 t = ('王大锤', 20, True, '隔壁')
14 print(t)
15 # 将元组转换成列表
16 person = list(t)
17 print(person)
18 # 列表是可以修改它的元素的
19 person[0] = '李小龙'
20 person[1] = 25
21 print(person)
22 # 将列表转换成元组
23 fruits_list = ['apple', 'banana', 'orange']
24 fruits_tuple = tuple(fruits_list)
25 print(fruits_tuple)

这里有一个非常值得探讨的问题，我们已经有了列表这种数据结构，为什么还需要元组这样的类型呢？

  1. 元组中的元素是无法修改的，事实上我们在项目中尤其是多线程环境（后面会讲到）中可能更喜欢使用的是那些不变对象（一方面因为对象状态不能修改，所以可以避免由此引起的不必要的程序错误，简单的说就是一个不变的对象要比可变的对象更加容易维护；另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问）。所以结论就是：如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。
  2. 元组在创建时间和占用的空间上面都优于列表。我们可以使用sys模块的getsizeof函数来检查存储同样的元素的元组和列表各自占用了多少内存空间，这个很容易做到。如下我们可以看到，元组的初始化速度，要比列表快 5 倍。但如果是索引操作的话，两者的速度差别非常小，几乎可以忽略不计。
python3 -m timeit 'x=(1,2,3,4,5,6)'
20000000 loops, best of 5: 9.97 nsec per loop
python3 -m timeit 'x=[1,2,3,4,5,6]'
5000000 loops, best of 5: 50.1 nsec per loop

使用集合

Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。但是集合并不支持索引操作，因为集合本质上是一个哈希表，和列表不一样。

可以按照下面代码所示的方式来创建和使用集合。

 1 # 创建集合的字面量语法
 2 set1 = {1, 2, 3, 3, 3, 2}
 3 print(set1)
 4 print('Length =', len(set1))
 5 # 创建集合的构造器语法(面向对象部分会进行详细讲解)
 6 set2 = set(range(1, 10))
 7 set3 = set((1, 2, 3, 3, 2, 1))
 8 print(set2, set3)
 9 # 创建集合的推导式语法(推导式也可以用于推导集合)
10 set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
11 print(set4)

向集合添加元素和从集合删除元素。

1 set1.add(4)
2 set1.add(5)
3 set2.update([11, 12])
4 set2.discard(5)
5 if 4 in set2:
6     set2.remove(4)
7 print(set1, set2)
8 print(set3.pop())
9 print(set3)

集合的成员、交集、并集、差集等运算。

 1 # 集合的交集、并集、差集、对称差运算
 2 print(set1 & set2)
 3 # print(set1.intersection(set2))
 4 print(set1 | set2)
 5 # print(set1.union(set2))
 6 print(set1 - set2)
 7 # print(set1.difference(set2))
 8 print(set1 ^ set2)
 9 # print(set1.symmetric_difference(set2))
10 # 判断子集和超集
11 print(set2 <= set1)
12 # print(set2.issubset(set1))
13 print(set3 <= set1)
14 # print(set3.issubset(set1))
15 print(set1 >= set2)
16 # print(set1.issuperset(set2))
17 print(set1 >= set3)
18 # print(set1.issuperset(set3))

说明： Python中允许通过一些特殊的方法来为某种类型或数据结构自定义运算符（后面的章节中会讲到），上面的代码中我们对集合进行运算的时候可以调用集合对象的方法，也可以直接使用对应的运算符，例如&运算符跟intersection方法的作用就是一样的，但是使用运算符让代码更加直观。

使用字典

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

 1 # 创建字典的字面量语法
 2 scores = {'白元芳': 78, '狄仁杰': 82}
 3 print(scores)
 4 # 创建字典的构造器语法
 5 items1 = dict(one=1, two=2, three=3, four=4)
 6 # 通过zip函数将两个序列压成字典
 7 items2 = dict(zip(['a', 'b', 'c'], '123'))
 8 # 创建字典的推导式语法
 9 items3 = {num: num ** 2 for num in range(1, 10)}
10 print(items1, items2, items3)
11 # 通过键可以获取字典中对应的值
12 print(scores['白元芳'])
13 print(scores['狄仁杰'])
14 # 对字典中所有键值对进行遍历
15 for key in scores:
16     print(f'{key}: {scores[key]}')
17 # 更新字典中的元素
18 scores['白元芳'] = 65
19 scores['诸葛王朗'] = 71
20 scores.update(冷面=67, 方启鹤=85)
21 print(scores)
22 if '武则天' in scores:
23     print(scores['武则天'])
24 print(scores.get('武则天'))
25 # get方法也是通过键获取对应的值但是可以设置默认值
26 print(scores.get('武则天', 60))
27 # 删除字典中的元素
28 print(scores.popitem())
29 print(scores.popitem())
30 print(scores.pop('狄仁杰', 82))
31 # 清空字典
32 scores.clear()
33 print(scores)

字典和集合的内部结构都是一张哈希表。

  • 对于字典而言，这张表存储了哈希值（hash）、键和值这 3 个元素。

  • 而对集合来说，区别就是哈希表内没有键和值的配对，只有单一的元素了。

插入操作

每次向字典或集合插入一个元素时，Python 会首先计算键的哈希值（hash(key)），再和 mask = PyDicMinSize - 1 做与操作，计算这个元素应该插入哈希表的位置 index = hash(key) & mask。如果哈希表中此位置是空的，那么这个元素就会被插入其中。

而如果此位置已被占用，Python 便会比较两个元素的哈希值和键是否相等。

  • 若两者都相等，则表明这个元素已经存在，如果值不同，则更新值。

  • 若两者中有一个不相等，这种情况我们通常称为哈希冲突（hash collision），意思是两个元素的键不相等，但是哈希值相等。这种情况下，Python 便会继续寻找表中空余的位置，直到找到位置为止。

查找操作

和前面的插入操作类似，Python 会根据哈希值，找到其应该处于的位置；然后，比较哈希表这个位置中元素的哈希值和键，与需要查找的元素是否相等。如果相等，则直接返回；如果不等，则继续查找，直到找到空位或者抛出异常为止。

删除操作

对于删除操作，Python 会暂时对这个位置的元素，赋于一个特殊的值，等到重新调整哈希表的大小时，再将其删除。

不难理解，哈希冲突的发生，往往会降低字典和集合操作的速度。因此，为了保证其高效性，字典和集合内的哈希表，通常会保证其至少留有 1/3 的剩余空间。随着元素的不停插入，当剩余空间小于 1/3 时，Python 会重新获取更大的内存空间，扩充哈希表。不过，这种情况下，表内所有的元素位置都会被重新排放。

虽然哈希冲突和哈希表大小的调整，都会导致速度减缓，但是这种情况发生的次数极少。所以，平均情况下，这仍能保证插入、查找和删除的时间复杂度为 O(1)。

posted @ 2020-02-18 14:42  缘溪行  阅读(294)  评论(0)  编辑  收藏  举报