Python 理论知识（五）基本变量类型

1、列表

1.1、基本概念

• 列表是有序的元素集合，所有元素放在一对中括号中，用逗号隔开，没有长度限制；
• 列表索引值以0为开始值，-1为从未尾的开始位置。
• 列表可以使用+操作符进行拼接，使用*表示重复。
• 当列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有缝隙；
• 列表中的元素可以是不同类型的

1.2、列表的使用方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14

list = ["tsinbei","blog","blog.tsinbei.com",1234,[0,1,2,[1,2]]]

#创建一个列表

#一个列表里可以有多种数据类型

#甚至可以嵌套列表来做二或三维列表

print(list[0])
print(list[2])
print(list[4][2])
print(list[4][3][0])
print(list[-1])
print(list[-2])

结果：

此处内容需要评论回复（自动审核）或加入 QQ 技术交流群（立即获得内容）后方可阅读。赞助（二维码在文章下方）后联系作者可一次性解锁所有（包括之后的新文章）。

1.3、列表的基本操作

1.4、列表的相关方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

>>> a = [2,0,9,1,5]
>>> b = ['c','w','b','a']
>>> a.append(9)
>>> a
[2, 0, 9, 1, 5, 9]
>>> a.sort()
>>> a
[0, 1, 2, 5, 9, 9]
>>> a.reverse()
>>> a
[9, 9, 5, 2, 1, 0]
>>> b.sort()
>>> b
['a', 'b', 'c', 'w']
>>> a.index(5)
2
>>> a.insert(2,7)
>>> a
[9, 9, 7, 5, 2, 1, 0]
>>> a.count(9)
2
>>> a.remove(9)
>>> a
[9, 7, 5, 2, 1, 0]
>>> a.pop(0)
9
>>> a
[7, 5, 2, 1, 0]

1.5、列表推导式

• 列表推导式（又称列表解析式）提供了一种简明扼要的方法来创建列表。
• 它的结构是在一个中括号里包含一个表达式，然后是一个for语句，然后是 0 个或多个 for 或者 if 语句。那个表达式可以是任意的，意思是你可以在列表中放入任意类型的对象。返回结果将是一个新的列表，在这个以 if 和 for 语句为上下文的表达式运行完成之后产生。
• 列表推导式的执行顺序：各语句之间是嵌套关系，左边第二个语句是最外层，依次往右进一层，左边第一条语句是最后一层。

1
2
3
4
5

data = [i for i in range(10)]
#等价于
data = []
for i in range(10):
    data.append(i)

1
2
3
4
5

data = [2**i for i in range(10)]
#等价于
data = []
for i in range(10):
    data.append(2**i)

1
2
3
4
5
6

data = [num for num in range(20) if num%2==1]
#等价于
data = []
for num in range(20):
    if num%2==1:
        data.append(num)

1.6、应用

题目：

1个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配。

答案：

此处内容需要评论回复（自动审核）或加入 QQ 技术交流群（立即获得内容）后方可阅读。赞助（二维码在文章下方）后联系作者可一次性解锁所有（包括之后的新文章）。

运行结果如下:

2、元组

2.1、基本概念

• 元组（tuple）是包含多个元素的类型，元素之间用逗号分割
  如：t1 =(123,456,"hello")
• 可以通过把若干元素放在一对圆括号中创建元组，如果只有一个元素的话则需要多加一个逗号，例如(3,)。
• 也可以使用tuple()函数把列表、字典、集合、字符串以及range对象、map对象、zip对象或其他类似对象转换为元组。
• 元组可以是空的，t2=()
• 一个元组也可以作为另一个元组的元素，此时，作为元素的元组需要增加括号，从而避免歧义，如：t3=(123,456,("hello","world"))
• Python 的元组与列表类似，不同之处在于元组的元素不能修改。

2.2、元组的使用

1
2
3
4
5

>>> a = ('hello',2020,110)
>>> a
('hello', 2020, 110)
>>> a[1]
2020

元组中的元素值是不允许修改和删除的，但我们可以使用del语句来删除整个元组。

1
2
3
4
5
6
7
8
9

>>> a = ('hello',2020,'blog.tsinbei.com')
>>> print(a)
('hello', 2020, 'blog.tsinbei.com')
>>> del a
>>> print(a)
Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    print(a)
NameError: name 'a' is not defined

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

1
2
3
4
5
6
7
8
9
10

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

3、字典

3.1、基本概念

• 字典是无序的对象集合，使用键-值(key-value) 存储，具有极快的查找速度。
• 键(key)必须使用不可变类型
• 同一个字典中，键(key)必须是唯一的
• 字典的每个键值key => value对用冒号:分割，每个键值对之间用逗号,分割，整个字典包括在花括号}中，格式如下所示:
• dic = {key1 : value1, key2 : value2 }
• 字典键一般是唯的,如果重复最后的一一个键值对会替换前面的,值不需要唯一。
• 键必须不可变，所以可以用数字，字符串或元组充当

例：

1
2
3

>>> tsinbei = {'website':'blog.tsinbei.com','name':'HsukqiLee'}
>>> tsinbei['website']
'blog.tsinbei.com'

3.2、常用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

>>> tsinbei = {'website':'blog.tsinbei.com','name':'HsukqiLee'}
>>> tsinbei.keys()
dict_keys(['website', 'name'])
>>> tsinbei.values()
dict_values(['blog.tsinbei.com', 'HsukqiLee'])
>>> tsinbei.items()
dict_items([('website', 'blog.tsinbei.com'), ('name', 'HsukqiLee')])
>>> tsinbei.copy()
{'website': 'blog.tsinbei.com', 'name': 'HsukqiLee'}
>>> test = {'website':'pan.tsinbei.com'}
>>> tsinbei.update(awsl)
>>> tsinbei
{'website': 'pan.tsinbei.com', 'name': 'HsukqiLee'}
>>> tsinbei.get('website') 'pan.tsinbei.com'
>>> tsinbei.get('tsinbei','666')
'666'
>>> tsinbei.clear()
>>> tsinbei
{}
>>> dict = {'Name': 'HsukqiLee', 'Age': 20, 'Class': 'First'}
>>> str(dict)
"{'Name': 'HsukqiLee', 'Class': 'First', 'Age': 20}"

3.3、字典元素修改、添加与删除

• 可以使用字典对象的pop()删除指定“键”对应的元素，同时返回对应的“值"
• popitem()方法用于删除字典的一个键对，并返回一个包含两个元素的元组，其中的两个元素分别是字典元素的“键”和“值"。
• 也可以使用del删除指定的“键”对应的元素。

4、集合

4.1、概述

• Python集合是无序、可变的容器对象,所有元素放在一对大括号中，元素之间使用逗号分隔，同一个集合内的每个元素都是唯一的, 不允许重复，
• 集合中只能包含数字、字符串、元组等不可变类型的数据，而不能包含列表.字典、集合等可变类型的数据，包含列表等可变类型数据的元组也不能作为集合的元素。
• 集合中的元素是无序的，元素存储顺序和添加顺序并不一致。
• 集合不支持使用下标直接访问特定位置上的元素，也不支持使用 random中的 choice()函数从集合中随机选取元素，但支持使用 random模块中的 sample()函数随机选取部分元素。

4.2、set(集合)

• set和dict类似， 也是一组key的集合,但不存储value。由于key不能重复，所以,在set中，没有重复的key。
• set是无序的，重复元素在set中自动被过滤。
• 可以使用大括号 { }或者 set()函数创建集合，注意：创建一个空集合必须用 set()而不是 { }，因为 { }是用来创建一个空字典。
• set可以看成数学意义上的无序和无重复元素的集合,因此，两个set可以做数学意义上的交集(&)、井集(|)、差集(-)等操作。

4.3、集合的常用方法

• s = add(x)：将元素x添加到集合s中，如果元素已存在，则不进行任何操作。
• s = update(x)：将x的元素添加到集合s中，x可以是列表，元组，字典等。
• s.pop(x)：随机删除集合中的一个元素。
• s.remove(x)：将元素x从集合s中移除，如果元素不存在，则会发生错误。
• s.discard(x)：将元素x从集合s中移除,如果元素不存在，不会发生错误。
• len(s)：计算集合 s 元素个数。
• s.clear()：清空集合 s。

5、字符串

5.1、概述

• 字符串(str)是用双引号""或者单引号''括起来的一个或多个字符
• 字符串可以保存在变量中，也可以单独存在
• 字符串属于不可变对象，所有方法都是返回处理后的字符串或字节串,不对原字符串进行任何修改。

5.2、字符串操作

• 字符串之间可以通过+或*进行连接

  • 加法操作(+)将两个字符串连接成为一个新的字符串
  • 乘法操作(*)生成一个由其本身字符串重复连接而成的字符串
  • x in s:如果x是s的子串，返回True,否则返回False
  • str[N:M]:切片, 返回子串

• len()函数能返回-一个字符串的长度

  • str1="hello,world"
  • len(str1)
• 大多数数据类型都可以通过 str()函数转换为字符串:如 str(123)
• type()函数测试一个字符串的类型

5.3、字符串操作

• index(x)、rindex(x): 检测x是否包含在字符串中，返回相应的索引值，如果不存在。返回异常。
• count(x)：返回x在string里面出现的次数。
• replace(str1,str2[,max])：把将字符串中的str1替换成str2,如果max指定，则替换不超过max次。
• maketrans()：创建字符映射的转换表。
• translate(str)：根据str给出的映射转换表转换string字符。
• ljust(width[,fllchar]): 返回一个原字符串左对齐，并使用fillchar填充至长度width的新字符串，fillchar默认为空格。rjust()、center()类似。
• split(str="",num=string.count(str)),其中num=string.count(str))以str为分隔符截取字符串，如果num有指定值，则仅截取num+1个子字符串。rsplit()类似，从右侧开始截取。
• join(seq): 以指定字符串作为分隔符，将seq中所有的元素(的字符串表示)合并为一个新的字符串。
• startswith(substr)、endswith(substr)：检查字符串是否是以指定子字符串substr开头或结束，是则返回True。
• strip()、rstrip()、lstrip(): 截取字符串的指定字符。

6、字符串格式化

6.2、格式化操作符辅助指令:

6.3、应用

编写程序，完成以下要求：

统计字符串中，各个字符的个数
比如："hello world"
字符串统计的结果为
h:1 e:1 l:3 o:2 d:1 r:1 w:1

答案：

1
2
3
4
5
6
7
8
9

a="hello world"
b=[]
for i in a.replace(" ",""):
    if i in b:
        pass
    else:
        b.append(i)
for i in b:
    print("%s:%s"%(i,a.count(i)))

7、鸣谢

转载自：
Zeruns's Blog