1. 字符串切片

从本质上讲，字符串是由多个字符构成的，字符之间是有顺序的，这个顺序号称为索引（index）。

  1. 获取单个字符

在方括号 [ ] 中使用索引即可访问对应的字符，具体的语法格式为：

1
strname[index]

Python 允许从字符串的两端使用索引：

  • 当以字符串的左端（字符串的开头）为起点时，索引是从 0 开始计数的；字符串的第一个字符的索引为 0，第二个字符的索引为 1，第三个字符串的索引为 2 ……
  • 当以字符串的右端（字符串的末尾）为起点时，索引是从 -1 开始计数的的；字符串的倒数第一个字符的索引为 -1，倒数第二个字符的索引为 -2，倒数第三个字符的索引为 -3 ……
  1. 获取多个字符（字符串截去 / 字符串切片）

使用门除了可以获取单个字符外，还可以指定一个范围来获取多个字符，也就是一个子串或者片段，具体格式为：

1
strname[start : end : step]

2. List 列表

2.1 列表定义

从形式上看，列表会将所有元素都放在一对中括号 [ ] 里面，相邻元素之间用逗号 , 分隔，如下所示：

1
[element1, element2, element3, ..., elementn]

创建列表

在 Python 中，创建列表的方法可分为两种：

  1. 使用 [ ] 直接创建列表

使用 [ ] 创建列表后，一般使用 = 将它赋值给某个变量，具体格如下：

1
listname = [element1, element2, element3 , ... , elementkn]

其中，listname 表示变量名，element1 ~ elementn 表示列表元素。

  1. 使用 list( ) 函数创建列表

除了使用 [ ] 创建列表外，Python 还提供了一个内置的函数 list( )，使用它可以将其它数据类型转换为列表类型。

1
2
3
4
5
6
7
8
9
# 将字符串转换成列表
username = "helloworld"
list1 = list(username)
print(list1)

# 将元组转换成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2)

2.2 增删改查

访问列表元素

列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。

  • 使用索引访问列表元素的格式为：listname[i]

其中，listname 表示列表名字，i 表示素引值。列表的索引可以是正数，也可以是负数。

  • 使用切片访问列表元素的格式为：listname[start:end:step]

其中，listname 表示列表名字，start 表示起始索引，end 表示结束索引，step 表示步长。

Tips：

索引从 0 开始而不是 1 开始，通过将索引指定为 -1，可以得到列表最后一个元素。

1
2
3
4
5
6
url = [1, 2, 3, 4, 5, 6, 7, 8]
print(url[2])       # 3
print(url[-2])      # 7
print(url[0:3])     # [1, 2, 3]
print(url[0:5:2])   # [1, 3, 5]
print(url[::])      # [1, 2, 3, 4, 5, 6, 7, 8]

添加列表元素

调用函数 操作方式 示例
list.append(元素) 在末尾处添加 name.append(‘fish’)
列表扩充 list.extend(list) 合并其他函数 names.extend(names)
list.insert(索引 , 元素) 在任意位置添加 names.insert(0 , ‘fish’)
列表相加 “+” 合并其他函数 names + names
  1. append( ) 方法

append( ) 方法用于在列表的末尾追加元素，该方法的语法格式如下：

1
listname.append(obj)

其中，listname 表示要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

1
2
3
4
5
6
7
list1 = ['Python', 'C++', 'Java']
print(list1)            # ['Python', 'C++', 'Java']
list1.append("PHP")
print(list1)            # ['Python', 'C++', 'Java', 'PHP']
list2 = [1, 2, 3]
list1.append(list2)
print(list1)            # ['Python', 'C++', 'Java', 'PHP', [1, 2, 3]]
  1. extend( ) 方法

extend( ) 方法同样也可以在末尾添加单个元素，但与 append 不同的是，当用 extend( ) 添加诸如列表对象时，不会将其视为一个整体添加进去，而是会将列表对象中的所有元素进行拆分，一个个的添加到新列表的末尾。

1
2
3
4
5
6
7
list1 = ['Python', 'C++', 'Java']
print(list1)            # ['Python', 'C++', 'Java']
list1.extend("PHP")
print(list1)            # ['Python', 'C++', 'Java', 'P', 'H', 'P']
list2 = ['C#', 'Go']
list1.extend(list2)
print(list1)            # ['Python', 'C++', 'Java', 'P', 'H', 'P', 'C#', 'Go']
  1. insert( ) 方法

前面两种方法都是添加到列表的末尾，如果想在列表中间插入元素，可以使用 insert 方法。

1
2
3
4
5
6
list1 = ['Python', 'C++', 'Java']
print(list1)            # ['Python', 'C++', 'Java']
list1.insert(-1, "PHP")
print(list1)            # ['Python', 'C++', 'PHP', 'Java']
list1.insert(1, "Go")
print(list1)            # ['Python', 'Go', 'C++', 'PHP', 'Java']

修改列表元素

1
2
3
4
【输入】
motorcycles = ['honda','yamaha','suzuki']
motorcycles[0] = 'ducati'
print(motorcycles)    # ['ducati', 'yamaha', 'suzuki']

删除列表元素

使用 pop( ) 可以弹出一个元素，一旦使用 pop( ) 之后，被弹出的元素就不在列表中了。

方法 remove( ) 只删除第一个指定的值，如果要删除的值可能在列表中出现多次，就需要使用循环。

调用函数 操作方式 示例
del 语句 删除某个索引的元素 del names[0]
del 语句 删除整个列表 del names
pop( ) 方法 弹出末尾元素 names.pop()
pop( ) 方法 弹出某索引元素 names.pop(0)
remove( ) 方法 删除某个值的元素 names.remove(‘dog’)
clear( ) 方法 清空列表中的元素 names.clear()

2.3 列表常见操作

组织列表

调用函数 操作方式 示例
sort( ) 方法 使列表元素按照字母顺序排序 cars.sort()
sorted( ) 方法 对列表进行临时排序，也是按字母顺序，但不会永久性改变 print(sorted(cars))
reverse( ) 方法 反转列表元素的排序顺序 cars.reverse()

其中 sorted( ) 和 sort( ) 的区别如下：

名称 类型 写法 执行结果 愿列表是否变化
sort() 列表的方法 xxx.sort() None 变化
sorted() 内置函数 sorted(xxx) 新列表 不变

列表复制

下面两段代码不一样：

  • 代码一是将 my_foods 复制给了 friend_foods 成为两个列表。
  • 代码二则是将 friend_foods 与 my_foods 划等号即实质上两个变量还是用的同一个列表，一方的删减会同步影响到另一方。
1
2
3
4
5
6
7
# 代码一
my_foods = ['pizza','falafel','carrot cake']
friend_foods = my_foods[:]

# 代码二
my_foods = ['pizza','falafel','carrot cake']
friend_foods = my_foods

列表的简单计算

函数 功能
min(list) 取列表的最小值
max(list) 取列表的最大值
sum(list) 取列表中所有元素的和

列表转换成字符串

如果我们想将列表中的字符拼接成一个字符串，则可以使用 join 函数，还可以指定拼接时的连接符。

1
2
3
list1 = ["h", "e", "l", "l", "o"]
print("".join(list1))       # hello
print("+".join(list1))      # h+e+l+l+o

Tips：

不光是列表可以使用 join 函数，下面的元组、字典和集合都可以使用 join 函数，其中字典是会拼接字典中的 key 值。

1
2
3
4
5
6
7
8
list1 = ("1", "2")
print("+".join(list1))      # 1+2

list2 = {"1":"go", "2":"lang"}
print("+".join(list2))       # 1+2

list3 = {"1", "2"}
print("+".join(list3))       # 2+1（因为集合是无序的）

3. Tuple 元组

元组（tuple）是 Python 中另一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排序的元素组成。

元组和列表（list）的不同之处在于:

  • 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列。
  • 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。

元组也可以看做是不可变的列表，通常情况下，元组用于保存无需修改的内容。

创建元组

Python 提供了两种创建元组的方法：

  1. 使用 ( ) 直接创建

通过 ( ) 创建元组后，一般使用 = 将它赋值给某个变量，具体格式为：

1
tuplename = (element1, element2, ..., elementn)

如果创建的元组只包含一个元素，则需要在后面加上逗号。

1
my_t = (3,)
  1. 使用 tuple( ) 函数创建元组

除了使用 ( ) 创建元组外，Python 还提供了一个内置的函数 tuple( )，用来将其它数据类型转换为元组类型。

Tips：

元组的访问时的语法与列表相同。

修改元组变量

修改变量不能通过修改列表元素那样去修改，需要重新定义。

1
2
3
4
dimensions = (200,50)    # (200,50)
print(dimensions)
dimensions = (400,100)
print(dimensions)        # (400,100)

4. Dict 字典

4.1 字典定义

Python 字典（dict）是 Python 中唯一的映射类型，是一种无序的、可变的序列，它的元素以 “ 键值对（key-value）” 的形式存储。

字典中将各元素对应的索引称为键（key），各个键对应的元素称为值（value），键及其关联的值称为 “ 键值对 “。

创建字典

  1. 使用 { } 创建字典

使用 { } 创建字典的语法格式如下：

1
dictname = {'key': 'value1', 'key2': 'value2', ..., 'keyn': 'valuen'}

由于字典中每个元素都包含两部分，分别是键（key）和值（value）。因此在创建字典时，键和值之间使用冒号 : 分隔，相邻元素之间使用逗号 , 分隔，所有元素放在大括号 { } 中。

1
2
alien_0 = {'color': 'green','points': 5}
print(alien_0['color'])    # green
  1. 通过 fromkeys( ) 方法创建字典

Python 中，还可以使用 dict 字典类型提供的 fromkeys( ) 方法创建带有默认值的字典，具体格式为：

1
dictname = dict.fromkeys(list, value=None)

其中，list 参数表示字典中所有键的列表（list）；value 参数表示默认值，如果不写，则为空值 None。

1
2
3
4
5
knowledge = ['语文', '数学', '英语']
scores = dict.fromkeys(knowledge)
print(scores)   # {'语文': None, '数学': None, '英语': None}
scores = dict.fromkeys(knowledge, 90)
print(scores)   # {'语文': 90, '数学': 90, '英语': 90}
  1. 通过 dict( ) 映射函数创建字典

格式 1：

1
dict1 = dict(key1="test1", key2="test2", key3="test3")

格式 2：

1
2
demo = [('two',2), ('one',1), ('three',3)]
dict2 = dict(demo)

格式 3：

1
2
3
keys = ['one', 'two', 'three']    # 还可以是数值或元组
values = [1, 2, 3]    # 还可以是字符串或元组
dict3 = dict(zip(keys, values))

4.2 增删改查

访问字典

列表和元组是通过下标来访问元素的，而字典不同，它通过键来访问对应的值。

  1. [ ] 访问字典元素
1
dictname[key]

其中，dictname 表示字典变量的名字，key 表示键名。注意，键必须是存在的，否则会抛出异常。

  1. get( ) 方法
1
dictname.get(key[,default])

其中，dictname 表示字典变量的名字；key 表示指定的键，是必不可少的；default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，就会返回 None，因此是可选的。

1
2
3
alien = {'color': 'green'}
print(alien.get('color','0'))      # green
print(alien.get('points','0'))     # 0

Tips：

判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符。

添加、修改和删除键值对

1
2
3
4
5
6
7
8
9
10
11
12
alien = {'color': 'green','points': 5}

#添加键值对
alien['x_position'] = 0
alien['y_position'] = 25

#修改键值对
alien['color'] = 'yellow'

#删除键值对
del alien['points']
print(alien_0)    # {'color': 'yellow', 'x_position': 0, 'y_position': 25}

查看 dict 所有方法

Python 字典的数据类型为 dict，我们可使用 dir(dict) 来查看该类型包含哪些方法。

1
2
>>> dir(dict)
['clear', 'copy', 'fromkeys', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values' ]

遍历字典

现在我定义了一个 favorite 字典，我想遍历字典中的值，则有三种方式可以遍历。

1
favorite = {'1': 'Python', '3': 'C++', '2': 'Python'}
  • 遍历所有键
1
2
3
4
5
6
7
# keys()方法用于返回字典中的所有键（key）
for name in favorite.keys():
    print(name)

# 也可以不用keys，会默认遍历所有key
for name in favorite:
    print(name)

此外，可以通过 sorted( ) 来获得特定顺序排列的键列表的副本：

1
2
for name in sorted(favorite.keys()):
    print(name)
  • 遍历所有值
1
2
3
4
5
6
7
8
# values()方法用于返回字典中所有键对应的值（value）
for language in favorite.values():
    print(language)
"""
Python
C++
Python
"""

此外，通过对包含重复元素的列表调用 set( ) ，可让 Python 找出列表中独一无二的元素。

1
2
3
4
5
6
for language in set(favorite.values()):
    print(language)
"""
Python
C++
"""
  • 遍历所有键值对
1
2
3
# items()用于返回字典中所有的键值对（key-value）
for k, v in favorite.items():
    print("key:", k, " value:", v)

4.3 字典嵌套

  • 在列表中存储字典
1
2
3
4
aliens = []
for alien_number in range(30):
    new_alien ={'color': 'green', 'points': 5}
    aliens.append(new_alien)
  • 在字典中存储列表
1
2
3
4
pizza = {
    'crust': 'thick',
    'toppings': ['mushrooms', 'extra cheese'],
}
  • 在字典中存储字典
1
2
3
4
5
6
7
8
9
10
11
12
users = {
    'aeinstein':{
        'first': 'albert',
        'last': 'einstein',
        'location': 'princeton',
    },
    'mcurie':{
        'first': 'marie',
        'last': 'curie',
        'location': 'paris',
    },
}

5. Set 集合

Python 中的集合，和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。形式上看，和字典类似，Python 集合会将所有元素放在一对大括号 { } 中，相邻元素之间用 , 分隔，如下所示：

1
{element1, element2, ..., elementn}

创建集合

  1. 使用 { } 创建

在 Python 中，创建 set 集合可以像列表、元素和字典一样，直接将集合赋值给变量，其语法格式如下：

1
setname = {element1, element2, ..., elementn}

集合会帮我们自动去重，并且不会以特定的顺序存储元素。

1
2
languages = {'python', 'ruby', 'python', 'c'}
print(languages)    # {'ruby','python','c}
  1. set( ) 函数创建集合

set( ) 函数为 Python 的内置函数，其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合。该函数的语法格式如下：

1
setname = set(iteration)

比如下面我将一个字符串转换成集合的形式，则会得到一个去重后的字符集。

1
2
str = "helloworld"
print(set(str))     # {'e', 'd', 'o', 'l', 'h', 'w', 'r'}

添加、删除集合元素

  • 添加元素

set 集合中添加元素，可以使用 set 类型提供的 add( ) 方法实现，该方法的语法格式为：

1
setname.add(element)
  • 删除元素

删除现有 set 集合中的指定元素，可以使用 remove( ) 方法，该方法的语法格式如下：

1
setname.remove(element)

差集、交集和并集

运算操作 Python 运算符 含义 例子
交集 & 取两集合公共的元素 >>> set1 & set2{3}
并集 \ 取两集合全部的元素 >>> set1 \ set2{1, 2, 3, 4, 5}
差集 - 取一个集合中另一个集合没有的元素 >>> set1 - set2{1, 2}>>> set2 - set1{4, 5}
对称差集 ^ 取集合 A 和 B 中不属于 A & B 的元素 >>> set1 ^ set2{1, 2, 4, 5}
方法名 语法格式 操作说明
difference( ) set3 = set1.difference(set2) 将 set1 中有而 set 2 没有的元素给 set3
intersection( ) set3 = set1.intersection(set2) 取 set1 和 set2 的交集给 set3
union( ) set3 = set1.union(set2) 取 set1 和 set2 的并集给 set3 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
list1 = [1, 2, 3, 4, 5]
list2 = [1, 2, 5, 6, 7]

# 差集
set1 = set(list2).difference(set(list1))
print(set1)     # {6, 7}

# 交集
set2 = set(list1).intersection(set(list2))
print(set2)     # {1, 2, 5}

# 并集
set3 = set(list1).union(set(list2))
print(set3)     # {1, 2, 3, 4, 5, 6, 7}

6. 获取对象长度

Python 中，要想知道一个对象长度，或者一个字符串占用多少个字节，可以使用 len 函数。

len 函数的基本语法格式为：

1
len(obj)

其中 obj 用于指定要进行长度统计的对象，可以是字符串、列表、元组、字典等。

以 UTF-8 编码为例，字符串 “ 人生苦短，我用 Python” 所占用的字节数如下图所示。

Tips：

在 UTF-8 编码中，英文每个字符占用 1 个字节，中文每个汉字占用 3 个字节。
在 gbk 编码中，英文每个字符占用 1 个字节，中文每个汉字占用 2 个字节。

通过使用 encode( ) 方法，将字符串进行编码后再获取它的字节数。例如，采用不同编码方式，计算 “ 人生苦短，我用 Python!” 的字节数，可以执行如下代码：

1
2
3
str1 = "人生苦短，我用Python!"
print(len(str1.encode('utf-8')))   # 28
print(len(str1.encode('gbk')))     # 21

7. Python 推导式

推导式 comprehensions（又称解析式），是 Python 的一种独有特性。推导式是可以从一个数据序列构建另一个新的数据序列的结构体，共有三种推导，在 Python2 和 3 中都有支持：

  • 列表（list）推导式
  • 字典（dict）推导式
  • 集合（set）推导式

列表推导式

列表推导式书写形式：

1
2
3
[表达式 for 变量 in 列表] 
或者 
[表达式 for 变量 in 列表 if 条件]

可以看一些例子来快速掌握。

1
2
3
4
5
6
7
8
9
10
11
list1 = [i for i in range(1, 10)]
print(list1)    # [1, 2, 3, 4, 5, 6, 7, 8, 9]

list2 = [i * 2 for i in range(1, 10)]
print(list2)    # [2, 4, 6, 8, 10, 12, 14, 16, 18]

list3 = [i * 2 for i in range(1, 10) if i > 5]
print(list3)    # [12, 14, 16, 18]

list4 = ["hello" for i in range(1, 10)]
print(list4)    # ['hello', 'hello', 'hello', 'hello', 'hello', 'hello', 'hello', 'hello', 'hello']

字典推导式

字典推导和列表推导的使用方法是类似的，只不过中括号该改成大括号。

1
2
3
4
5
6
7
# 快速调换key和value的位置
dict1 = {"a": 1, "b": 2, "c": 3, "d": 4}
dict1 = {value: key for key, value in dict1.items()}
print(dict1)  # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}

dict2 = {value * 2: key for key, value in dict1.items()}
print(dict2)  # {2: 'a', 4: 'b', 6: 'c', 8: 'd'}

集合推导式

集合推导式跟列表推导式差不多，都是对一个列表的元素全部执行相同的操作，但集合是一种无重复无序的序列，跟列表推导式的区别在于：

  1. 不使用中括号，使用大括号
  2. 结果中无重复
  3. 结果是一个 set( ) 集合
1
2
3
4
5
6
7
# 自动去重
list1 = [1, 2, 3, 4, 1, 2, 5]
set1 = {i for i in list1}
print(set1)  # {1, 2, 3, 4, 5}

set2 = {i * 2 for i in list1}
print(set2)  # {2, 4, 6, 8, 10}