但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串。

前面我们学习了，对于tuple，它和list一个最大的不同点就是tuple是不可变的，tuple里面的元素，也是不可替换的。但是这针对的是仅包含基础数据类型（数字类型、布尔类型、字符串类型）的数据，对于组合数据类型，则不受这个约束。

T = (1, 'CH', [3, 4])

这里T有三个元素，第一个元素是数字类型，第二个元素是字符串类型，第三个元素是列表类型的，我们尝试修改第三个元素的数据。

T = (1, 'CH', [3, 4])
L = T[2]
print(L) # ==> [3, 4]
# 尝试替换L中的元素
L[1] = 40
print(L) # ==> [3, 40]
print(T) # ==> (1, 'CH', [3, 40])

这个时候，我们发现，元组T中的第三个元素已经成功被改变了，这就有悖前面的定义，元组是不可改变的。那么这到底是为什么呢？
这是因为虽然tuple中的list元素改变了，但是tuple本身指向的list仍然是同一个list，list本身并没有改变，改变的只是list里面的一个元素，这是tuple所约束不到的范围。

T = (1, 'CH', [3, 4])
L2 = [3, 40]
# 尝试替换tuple中的list
T[2] = L2
# 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

如果我们直接替换list，这也是不行的。

需要注意的是，not计算的优先级是高于and和or的。

 int() 函数，其实就有两个参数，我们既可以传一个参数，又可以传两个参数：当传递两个参数的时候，前面一个说代表的是数，第二个数是第一个数的进制，将这个数输出的时候是按十进制输出。

字符串format由两个部分组成，字符串模板和模板数据内容组成，通过大括号{}，就可以把模板数据内容嵌到字符串模板对应的位置。

# 字符串模板
template = 'Hello {}'
# 模板数据内容
world = 'World'
result = template.format(world)
print(result) # ==> Hello World

字符串format由两个部分组成，字符串模板和模板数据内容组成，通过大括号{}，就可以把模板数据内容嵌到字符串模板对应的位置。

# 字符串模板
template = 'Hello {}'
# 模板数据内容
world = 'World'
result = template.format(world)
print(result) # ==> Hello World字符串format由两个部分组成，字符串模板和模板数据内容组成，通过大括号{}，就可以把模板数据内容嵌到字符串模板对应的位置。

# 字符串模板
template = 'Hello {}'
# 模板数据内容
world = 'World'
result = template.format(world)
print(result) # ==> Hello World字符串format由两个部分组成，字符串模板和模板数据内容组成，通过大括号{}，就可以把模板数据内容嵌到字符串模板对应的位置。

# 字符串模板
template = 'Hello {}'
# 模板数据内容
world = 'World'
result = template.format(world)
print(result) # ==> Hello World

如果模板中{}比较多，则容易错乱，那么在format的时候也可以指定模板数据内容的顺序。

# 指定顺序
template = 'Hello {0}, Hello {1}, Hello {2}, Hello {3}.'
result = template.format('World', 'China', 'Beijing', 'imooc')
print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc.
# 调整顺序
template = 'Hello {3}, Hello {2}, Hello {1}, Hello {0}.'
result = template.format('World', 'China', 'Beijing', 'imooc')
print(result) # ==> Hello imooc, Hello Beijing, Hello China, Hello World.

除了使用顺序，还可以指定对应的名字，使得在format过程更加清晰。

# 指定{}的名字w,c,b,i
template = 'Hello {w}, Hello {c}, Hello {b}, Hello {i}.'
world = 'World'
china = 'China'
beijing = 'Beijing'
imooc = 'imooc'
# 指定名字对应的模板数据内容
result = template.format(w = world, c = china, b = beijing, i = imooc)
print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc.

对于不存在的元素，count方法不会报错，而是返回0，这是合理的，因为元组里面有0个不存在的元素。

当指定的元素不存在时，使用index()方法Python会报错。

函数可以有多个参数（以逗号隔开），参数类型有 必需参数、关键字参数、默认参数、不定长参数。

# 必需参数：传入的值必须与函数参数列表的顺序和数量一致
def 函数名(必需参数1, 必需参数2, ...):
    # 函数体
结果 = 函数名(必需值1, 必需值2, ...)

# 关键字参数：不要求传入的顺序，但是调用时必须指定参数名
def 函数名(关键字参数1, 关键字参数2, ...):
    # 函数体
结果 = 函数名(关键字2 = 值1, 关键字1 = 值2, ...)
# 若参数列表中有单独的*，则*本身不代表参数，*之后的所有参数均为关键字参数
def 函数名(参数1, *, 参数2, ...):
    # 函数体
结果 = 函数名(值1, 参数2 = 值2, ...)

# 默认参数：给参数名设定默认值
# 默认参数必须在必需参数或关键字参数后面
def 函数名(默认参数=默认值, ...):
    # 若没有传入值，则使用默认值
结果 = 函数名(...)

# 不定长参数：参数数量不定
# 参数名前有一个*则以元组形式传入，有两个**则以字典形式传入
# 不定长参数放在最后，元组型不定长在字典型不定长前
def 函数名(*不定长参数1, **不定长参数2):
    # 函数体
结果 = 函数名(值1.1, 值1.2, ..., 参数2.1=值2.1, 参数2.2=值2.2, ...)

参数为不可变数据类型（数字、字符串、元组）时，类似于值传递，函数内变更参数值不影响函数外的参数值；

参数为可变数据类型（列表、集合、字典）时，类似于地址传递，函数内变更参数值会改变函数外的参数值。

# 判断参数类型
isinstance(参数, 数据类型)

result = template.format(world)

result = template.format('World', 'China', 'Beijing', 'imooc')

result = template.format(w = world, c = china, b = beijing, i = imooc)

前面我们讲解了什么是字符串。字符串可以用' '或者" "括起来表示。

如果字符串本身包含'怎么办？比如我们要表示字符串I'm OK ，这时，可以用" "括起来表示：

"I'm OK"

类似的，如果字符串包含"，我们就可以用' '括起来表示：

'Learn "Python" in imooc'

但是，如果字符串既包含'又包含"怎么办？

这个时候，就需要对字符串中的某些特殊字符进行“转义”，Python字符串用\进行转义。

要表示字符串Bob said "I'm OK"
由于'和"会引起歧义，因此，我们在它前面插入一个\表示这是一个普通字符，不代表字符串的起始，因此，这个字符串又可以表示为

'Bob said \"I\'m OK\".'

注意：转义字符 \不计入字符串的内容中。

常用的转义字符还有：

\n表示换行
\t 表示一个制表符
\\表示 \ 字符本身

Python提供isinstance()函数，可以判断参数类型，它接收两个参数，第一个是需要判断的参数，第二个是类型。