Python基础语法（四）—— 列表+元组+字典

---

一、列表和元组

列表和元组一组变量的集合，它们可以批量粗存储数据。
元组和列表是非常相似的，只是列表中存放的元素是可以修改的，而元组是不可变的（也就是不能修改），所以创建元组的时候就要设定好，不能修改调整

1. 创建列表

• 创建列表主要有两种方式

  list1 = []
  list2 = list()
  print(type(list1))
  print(type(list2))
  # 执行结果
  <class 'list'>
  <class 'list'>
  1
  2
  3
  4
  5
  6
  7

• 设置初始值

  my_list = [10, 3.14, 'hello']
  print(my_list)
  # 运行结果
  [10, 3.14, 'hello']
  1
  2
  3
  4

  Python列表中是可以存放不同类型的元素的，这和C/Java差别比较大

2. 下标访问

我们可以通过下标访问操作符[]来获取列表中的任意元素

• 从前往后访问下标是从0开始的
• Python的索引是可以取负数的（从后往前是从-1开始，也就是倒数第一个元素）
• 如果下标越界就会抛出异常

my_list = [1, 2, 3, 4, 5]
print(my_list[0])
print(my_list[3])
print(my_list[-1])
print(my_list[-5])
1
2
3
4
5

计算列表长度，通过len函数

my_list = [1, 2, 3, 4, 5]
print(len(my_list))
# my_list[-1]就相当于 my_list[len(my_list)-1]
1
2
3

3. 切片操作

通过下标能后一次获取一个元素
通过切片则是一次获取一组连续的元素，相当于一个子列表

语法格式

列表名[起始下标:结束下标:步长]

区间是左闭右开的
[起始下标:结束下标)
步长默认是1，也就是每次夸多少个元素
1
2
3
4
5

代码示例

lists = [1, 2, 'hello', 3.14, 'world']
print(lists[0:4:1])
print(lists[0:5:2])
print(lists[-1:-4:-1])
# 运行结果
[1, 2, 'hello', 3.14]
[1, 'hello', 'world']
['world', 3.14, 'hello']
1
2
3
4
5
6
7
8

在切片过程中可以省略前后边界

lists = [1, 2, 'hello', 3.14, 'world']
print(lists[1:]) # 省略后边界，表示获取到列表末尾
print(lists[:-1]) # 省略前边界，表示从开头开始获取
print(lists[:]) # 省略两个边界表示获取整个列表

#运行结果
[2, 'hello', 3.14, 'world']
[1, 2, 'hello', 3.14]
[1, 2, 'hello', 3.14, 'world']

lists = [1, 2, 'hello', 3.14, 'world']
print(lists[::-1])
print(lists[::1])
print(lists[::-2])
# 运行结果 
['world', 3.14, 'hello', 2, 1]
[1, 2, 'hello', 3.14, 'world']
['world', 'hello', 1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

如果切片中填的数字越界了，不会有负面效果，只会尽可能的把满足条件的元素获取到

lists = [1, 2, 'hello', 3.14, 'world']
print(lists[:500])
print(lists[100:])
运行结果
[1, 2, 'hello', 3.14, 'world']
[]
1
2
3
4
5
6

4. 变量列表元素

通过for循环遍历整个列表

lists = [1, 2, 'hello', 3.14, 'world']
for tmp in lists:
    print(tmp, end=' ')
print()
for i in range(len(lists)-1, -1, -1):
    print(lists[i], end=' ')

# 运行结果
1 2 hello 3.14 world 
world 3.14 hello 2 1 
1
2
3
4
5
6
7
8
9
10

5. 新增元素

• 使用append方法，向列表末尾插入一个元素

lists = [1, 2, 'hello', 3.14, 'world']
lists.append(1000)
lists.append('test')
print(lists)

# 运行结果
[1, 2, 'hello', 3.14, 'world', 1000, 'test']
1
2
3
4
5
6
7
8

• 使用insert方法，向任意位置插入一个元素

lists = [1, 2, 'hello', 3.14, 'world']
print(lists)
lists.insert(2, 'hahaha')
print(lists)

# 运行结果
[1, 2, 'hello', 3.14, 'world']
[1, 2, 'hahaha', 'hello', 3.14, 'world']
1
2
3
4
5
6
7
8

6. 查看元素

• 使用in操作符，判断元素是否在列表中存在，相反not in则是判断元素是否不在列表中

lists = [1, 2, 'hello', 3.14, 'world']
print('hello' in lists)
print(2 in lists)
print(44 in lists)
print(44 not in lists)

# 运行结果
True
True
False
True
1
2
3
4
5
6
7
8
9
10
11

• 使用index方法。查找元素在列表中的下标，放回一个整数，如果元素不存在就会抛出异常

lists = [1, 2, 'hello', 3.14, 'world']
print(lists.index(2))
print(lists.index('haha')) # 不存在会抛异常
1
2
3

7. 删除元素

• 使用pop方法删除最末尾的元素，也可以使用下标来删除元素

lists = [1, 2, 'hello', 3.14, 'world']
print(lists.pop())
print(lists)
lists.pop(2)
print(lists)

# 运行结果
world
[1, 2, 'hello', 3.14]
[1, 2, 3.14]
1
2
3
4
5
6
7
8
9
10

• 使用 remove，按照值来删除元素

lists = [1, 2, 'hello', 3.14, 'world']
lists.remove(2)
lists.remove('hello')
print(lists)
# 运行结果
[1, 3.14, 'world']
1
2
3
4
5
6

8. 合并列表

• 使用+能够把两个列表拼接起来，返回一个新列表不会影响到就列表

my_list = [10, 3.14, 'hello']
lists = [1, 2, 'hello', 3.14, 'world']
print(my_list + lists)
print(lists + my_list)

# 运行结果
[10, 3.14, 'hello', 1, 2, 'hello', 3.14, 'world']
[1, 2, 'hello', 3.14, 'world', 10, 3.14, 'hello']
1
2
3
4
5
6
7
8

• 使用 extend方法，相当于把一个列表拼接到另一列表后面
  注意：a.extend(b)，是把b中的内容拼接到a的末尾，不会修改b但是会修改a

my_list = [10, 3.14, 'hello']
lists = [1, 2, 'hello', 3.14, 'world']
my_list.extend(lists)
print(my_list)
print(lists)

# 运行结果
[10, 3.14, 'hello', 1, 2, 'hello', 3.14, 'world']
[1, 2, 'hello', 3.14, 'world']
1
2
3
4
5
6
7
8
9

• 使用append方法则是把整个列表当成一个元素拼接到后面

my_list = [10, 3.14, 'hello']
lists = [1, 2, 'hello', 3.14, 'world']
my_list.append(lists)
print(my_list)
print(lists)

# 运行结果
[10, 3.14, 'hello', [1, 2, 'hello', 3.14, 'world']]
[1, 2, 'hello', 3.14, 'world']
1
2
3
4
5
6
7
8
9

9. 关于元组

元组的功能和列表相比基本是相同的，只不过元组是不可变的

元组的创建，元组使用 ()来表示

my_tuple = tuple()
a_tuple = ()
print(type(my_tuple))
print(type(a_tuple))
# 运行结果
<class 'tuple'>
<class 'tuple'>
1
2
3
4
5
6
7

元组的访问

my_tuple = ('a', 10, 3.14)
print(my_tuple[2])
# 运行结果
3.14
1
2
3
4

元组不能修改，但切片、遍历、in、inde、+ 等操作也是一样支持的，像增删改这些操作就不支持了

my_tuple = ('a', 10, 3.14)
a_tuple = ('hello', 66)
print(my_tuple[:5])
print(my_tuple.index(10))
print(my_tuple + a_tuple)
print('hello' in a_tuple)

# 运行结果
('a', 10, 3.14)
1
('a', 10, 3.14, 'hello', 66)
True
1
2
3
4
5
6
7
8
9
10
11
12

另外，元组在Python中很多时候是默认的集合类型，列如，当一个函数要返回多个返回值的时候

def test():
    return 10, 'hello'


ret = test()
print(type(ret))

# 运行结果
<class 'tuple'>
1
2
3
4
5
6
7
8
9

10. 小结

既然有了列表，为啥还需要元组？

• 你有一个列表, 现在需要调用一个函数进行一些处理. 但是你有不是特别确认这个函数是否会把你的列表数据弄乱. 那么这时候传一个元组就安全很多
• 字典是一个键值对结构. 要求字典的键必须是 “可hash对象” (字典本质上也是一个hash表). 而一个可hash对象的前提就是不可变. 因此元组可以作为字典的键, 但是列表不行.
• 如果元素不需要改变, 则优先考虑元组.
• 如果元素需要改变, 则优先考虑列表

二、字典

1. 字典是啥？

在Python中字典是一种存储键值对的结构，一个 key 对应一个 value。且这个键(key)一定是唯一的
底层使用的哈希表，它的增删改查都是常数级的。

2. 创建字典

• 创建空的字典，使用 {}表示字典

amap = {}
my_map = dict()
print(type(amap))
print(type(my_map))
# 运行结果
<class 'dict'>
<class 'dict'>
1
2
3
4
5
6
7

• 也可以在创建的同时指定初始值
• 键值对之间使用逗号,分割，键和值使用冒号:分割

# 最后一个键值对的逗号可写可不写
student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18
}
print(student)
# 运行结果
{'name': 'zhangsan', 'sex': 'boy', 'age': 18}
1
2
3
4
5
6
7
8
9

3. 查找key

• 使用in可以判定key是否在字典中存在，返回 布尔值

  student = {
      'name': 'zhangsan',
      'sex': 'boy',
      'age': 18
  }
  print('name' in student)
  print('phone' in student)
  # 运行结果
  True
  False
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

• 使用[]通过类似于取下标的方式，获取到元素的值，只不过此处的下标是 键(key)，这个键可以是整数也可以是字符串或者是其它类型

student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
print(student['name'])
print(student[666])
# 运行结果
zhangsan
id
1
2
3
4
5
6
7
8
9
10
11

• 注意如果key在字典中不存在就会抛出异常

4. 新增&修改元素

使用 [] 可以根据key来新增/修改value

• 如果key不存在，对取下标操作赋值，即为新增键值对

student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}

student[666] = 9494
print(student)
# 运行结果
{'name': 'zhangsan', 'sex': 'boy', 'age': 18, 666: 9494}
1
2
3
4
5
6
7
8
9
10
11

• 如果key已经存在，对取下标操作赋值，就是进行修改操作

student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
student['name'] = 'lisi'
print(student)
# 运行结果
{'name': 'lisi', 'sex': 'boy', 'age': 18, 666: 'id'}
1
2
3
4
5
6
7
8
9
10

5. 删除元素

• 使用pop方法根据key删除对应的键值对

student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
student.pop(666)
print(student)
# 运行结果
{'name': 'zhangsan', 'sex': 'boy', 'age': 18}
1
2
3
4
5
6
7
8
9
10

6. 遍历字典元素

• 直接使用for循环能够获取到字典中所有key，进一步的就可以去除每个值了

student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
for key in student:
    print(key, student[key])

# 运行结果
name zhangsan
sex boy
age 18
666 id

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

7. 取出所有key和value

• 使用keys方法可以获取到字典中所有的key

student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
print(student.keys())
# 运行结果
dict_keys(['name', 'sex', 'age', 666])
1
2
3
4
5
6
7
8
9

此处 dict_keys 是一个特殊的类型, 专门用来表示字典的所有 key. 大部分元组支持的操作对于
dict_keys 同样适用

• 使用values方法可以获取到所有字典中的所有value

student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
print(student.values())
# 运行结果
dict_values(['zhangsan', 'boy', 18, 'id'])
1
2
3
4
5
6
7
8
9

此处 dict_values 也是一个特殊的类型, 和 dict_keys 类似

• 使用items方法可以获取到字典中所有的键值对

student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
print(student.items())
# 运行结果
dict_items([('name', 'zhangsan'), ('sex', 'boy'), ('age', 18), (666, 'id')])
1
2
3
4
5
6
7
8
9

此处 dict_items 也是一个特殊的类型, 和 dict_keys 类似.

8. 合法的key类型

需要注意的是，不是所有的类型都可以作为字典的key
字典本质上是一个 哈希表, 哈希表的 key 要求是 “可哈希的”, 也就是可以计算出一个哈希值

• 可以使用hash函数计算某个对象的哈希值
• 但凡能够计算出哈希值的类型，都可以作为字典的key

print(hash(666)) # 整数
print(hash(3.14)) # 浮点数
print(hash('hello world')) # 字符串
print(hash(False)) # 布尔
print(hash((1, 2, 'test'))) # 元组

# 运行结果
666
322818021289917443
8827197857303815004
0
6581628079282140115
1
2
3
4
5
6
7
8
9
10
11
12

• 列表和字典无法计算哈希值

print(hash([1, 2, 3, 'ha']))
print(hash({'name' : 'zhangsan'}))

1
2
3

小结

• 字典也是一个常用的结构，字典的所有操作都是围绕key来展开的
• 字典的键Key是唯一的

三、字符串

1. 字符串的定义

在Python中，用引号引起来的都是字符串。

string1 = "hello"
string2 = "hello"
string3 = """hello
python"""
string4 = '''hello
python'''
string5 = input("->")
string6 = str(666)

print(isinstance(string4, str)) # isinstance函数可以用来判断数据是否为某一个数据类型，返回值为
True或False
1
2
3
4
5
6
7
8
9
10
11

2. 字符串的拼接

name = "test"
str1 = "===" + name + "==="
str2 = "===%s==="%(name)
str3 = "==={}===".format(name)

print(str1)
print(str2)
print(str3)

# 输出都一样
===test===
===test===
===test===

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

3. 字符串的索引

遍历字符串

str = "hello world"
for tmp in str:
    print(tmp,end=" ")
1
2
3

将字符串遍历打印,并对应打印出下标

# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列

str = "hello world"
for index, c in enumerate(str):
    print(f'str[{index}] ch={c}')


# 输出
str[0] ch=h
str[1] ch=e
str[2] ch=l
str[3] ch=l
str[4] ch=o
str[5] ch= 
str[6] ch=w
str[7] ch=o
str[8] ch=r
str[9] ch=l
str[10] ch=d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4. 字符串的切片

字符串，列表，元组都属于序列，所以都可以切片
切片规则
[起始下标:结束下标:步长]

str = "hello-world"
print(str[:5]) # 从0到4个字符，不包含第5个
print(str[6:20]) #从第6个一直到最后

print(str[0:-1]) # 取第一个到倒数第2个不包含最后一个
print(str[3:]) # 从第3个取到最后一个
print(str[:]) # 全取
print(str[1:6:2]) # 取第1个到第6个步长为2

print(str[::-1]) # 字符串逆序

# 输出
hello
world
hello-worl
lo-world
hello-world
el-
dlrow-olleh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5. 字符串的常见操作

str = "hello world, Python"

# 调用len()函数来算长度
print(str.__len__()) # 使用字符串的__len__()方法来算字符串的长度
print(str.capitalize()) # 整个字符串的首字母大写
print(str.title()) # 每个单词的首字母大写
print(str.upper()) # 全大写
print(str.lower()) # 全小写
print("HAHAhehe".swapcase()) # 字符串里大小写互换
print(str.center(50, "*")) # 一共50个字符,字符串放中间，不够的两边补*
print(str.ljust(50, "*")) # 一共50个字符,字符串放中间，不够的右边补*
print(str.rjust(50, "*")) # 一共50个字符,字符串放中间，不够的左边补*
print(" haha\n".strip()) # 删除字符串左边和右边的空格或换行
print(" haha\n".lstrip()) # 删除字符串左边的空格或换行
print(" haha\n".rstrip()) # 删除字符串右边的空格或换行
print(str.endswith("you")) # 判断字符串是否以you结尾
print(str.startswith("hello")) # 判断字符串是否以hello开始
print(str.count("e")) # 统计字符串里e出现了多少次
print(str.find("nice")) # 找出nice在字符串的第1个下标，找不到会返回-1
print(str.rfind("e")) # 找出最后一个e字符在字符串的下标，找不到会返回-1
print(str.index("he")) # 与find类似，区别是找不到会有异常（报错）
print(str.rindex("e")) # 与rfind类似，区别是找不到会有异常（报错）

print(str.isalnum())    # 检测字符串是否由字母和数字组成
print(str.isalpha())    # 是否只由字母组成
print(str.isdecimal())  #检查字符串是否只包含十进制字符
print(str.isdigit())    # 检测字符串是否只由数字组成,只对 0 和 正数有效
print(str.islower())    # 检测字符串是否由小写字母
print(str.isnumeric())  # 法检测字符串是否只由数字组成
print(str.isspace())    #  方法检测字符串是否只由空格组成
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
29
30

输出

19
Hello world, python
Hello World, Python
HELLO WORLD, PYTHON
hello world, python
hahaHEHE
***************hello world, Python****************
hello world, Python*******************************
*******************************hello world, Python
haha
haha

 haha
False
True
1
-1
1
0
1
False
False
False
False
False
False
False
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

数字,字符串,元组是不可变类型.下面的操作可以替换字符串的值，但原字符串没有改变

str = "hello-world"

myStr = str.replace('l', 'L', 2) # 从左到右，把小写l替换成大写L，并且最多只替换2个
print(str)	# 原值不变
print(myStr)	# 改变的值赋值给了myStr变量，所以这里看到的是替换后的值
1
2
3
4
5

字符串分割

print("12:30:48".split(":"))# 以:为分隔号,分隔成列表
print("hello\nworld".splitlines()) # 以\n为分隔号，分隔成列表

# 输出
['12', '30', '48']
['hello', 'world']

1
2
3
4
5
6
7

字符串的join操作

print("=".join(['a', 'b', 'c'])) # 把列表里的元素以前面引号里的分隔符合成字符串

# 输出
a=b=c
1
2
3
4
5

---