Python笔记-2

1.链式赋值

链式赋值用于同一个对象赋值给多个变量。

x=y=123 相当于：x=123； y=123

2.系列解包赋值

系列数据赋值给对应相同个数的变量（个数必须保持一致）

>>> a,b,c=4,5,6

相当于：a=4;b=5;c=6

【操作】使用系列解包赋值实现变量交换

>>> a,b=1,2
>>> a,b=b,a#无需引入第三个变量
>>> print(a,b)
2,1

3.常量

Python 不支持常量，即没有语法规则限制改变一个常量的值。我们只能约定常量的命名规则，以及在程序的逻辑上不对常量的值作出修改。

>>> MAX_SPEED = 120
>>> print(MAX_SPEED)
120
>>> MAX_SPEED = 140
#实际是可以改的。只能逻辑上不做修改。
>>> print(MAX_SPEED)
140

4.最基本内置数据类型和运算符

每个对象都有类型（包含地址，类型，值），python 中最基本的内置数据类型：

（1）整型

整数，2345,10,50

（2）浮点型

小数，3.14 或者科学计数法 314e-2

（3）布尔型

表示真假，仅包含：True、False

（4）字符串型

由字符组成的序列。 “abc”,”sxt”,“尚学堂”,”百战程序员”

5.数字和基本运算符

Python 支持整数(如：50,520)和浮点数(如：3.14,10.0, 1.23e2)，我们可以对数字做如下

运算。

【操作】基本运算符的使用

>>> a = 7/2
>>> a
3.5
>>> a = 7//2
>>> a
3
>>> a = 7%2
>>> a
1
>>> 7%4
3
>>> 2**3
8
>>> 3/0
Traceback (most recent call last):
File "", line 1, in 
3/0
ZeroDivisionError: division by zero
>>> divmod(10,5)
(2, 0)
>>> divmod(10,3)
(3, 1)

除数为 0，会产生异常：

>>> 3/0
Traceback (most recent call last):
File "", line 1, in 
3/0
ZeroDivisionError: division by zero

使用 divmod()函数同时得到商和余数：

>>> divmod(13,3)
(4, 1)

divmod()是一个函数，返回的是一个元组。

6.整数

Python 中，除 10 进制，还有其他三种进制：

·0b 或 0B，二进制 0 1 (0，1，10，11，100，101，110，111，1000）

·0o 或 0O，八进制 0 1 2 3 4 5 6 7 （0....7，10，11，12）

·0x 或 0X，十六进制 0 1 2 3 4 5 6 7 8 9 a b c d e f （0...f，10）

这三种进制可以非常方便的进行“位运算”操作。位运算知识后续将会介绍。

【操作】测试不同进制

>>> 12
12
>>> 0b101
5
>>> 0o19
SyntaxError: invalid syntax
>>> 0o10
8
>>> 0xff
255
>>> 0xf
15
>>> 0x10
16

7.使用 int()实现类型转换：

（1）浮点数直接舍去小数部分。如：

int(9.9)结果是：9

（2） 布尔值 True 转为 1，False 转为 0。 如：

int(True)结果是 1

（3） 字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错。

>>> int("456")
456
>>> int("456abc")
Traceback (most recent call last):
File "", line 1, in 
int("456abc")
ValueError: invalid literal for int() with base 10: '456abc'
>>> int("456.78")
Traceback (most recent call last):
File "", line 1, in 
int("456.78")
ValueError: invalid literal for int() with base 10: '456.78'
>>>

8.自动转型：

整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：

2+8.0 的结果是 10.0

9.整数可以有多大？

Python2 中，

int 是 32 位，可以存储从-2147483648 到 2147483647 的整数（约± 21 亿）。Long 类型是 64 位，可以存储：-2^63--2^63-1 之间的数值。

Python3 中，

int 可以存储任意大小的整数，

long 被取消。我们甚至可以存储下面的值：

>>> googol = 10**100
>>> googol
100000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000

Googol 也是 Google 最初的名字，这也是 Google 最初的含义。

Python3 中可以做超大数的计算，而不会造成“整数溢出”，这也是 Python 特别适合科学运算的特点。

10.浮点数

浮点数，称为 float。

浮点数用 a* b 10 形式的科学计数法表示。比如：3.14，表示成：314E-2 或者 314e-2。

这些数字在内存中也是按照科学计数法存储。

11.类型转换和四舍五入

1. 类似于 int()，我们也可以使用 float()将其他类型转化成浮点数。

2. 整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：

2+8.0 的结果是 10.0

3. round(value)可以返回四舍五入的值

注：但不会改变原有值，而是产生新的值

12.增强型赋值运算符

运算符+、-、*，/、//、**和%和赋值符=结合可以 构成“增强型赋值运算符”。

a = a + 1 （原a值垃圾回收）

等价于： a +=1

注意：“+=”中间不能加空格！

13.时间的表示

计算机中时间的表示是从“1970 年 1 月 1 日 00:00:00”开始，以毫秒（1/1000 秒）进行计算。我们也把 1970 年这个时刻成为“unix 时间点”。

这样，我们就把时间全部用数字来表示了。

python 中可以通过 time.time() 获得当前时刻，返回的值是以秒为单位，带微秒（1/1000 毫秒）精度的浮点值。例如：1530167364.8566。

>>> import time
>>> b = int(time.time())
>>> b
1530168754
>>> totalMinutes = b/60
>>> totalMinutes
25502812.566666666
>>> totalMinutes = b//60
>>> totalMinutes
25502812
>>> totalHours = totalMinutes//60
>>> totalHours
425046
>>> totalDays = totalHours//24
>>> totalDays
17710
>>> totalYears = totalDays//365
>>> totalYears
48

【操作】定义多点坐标_绘出折线_并计算起始点和终点距离

源码

>>>import turtle
>>>import math
#定义多个点的坐标
x1,y1 = 100,100
x2,y2 = 100,-100
x3,y3 = -100,-100
x4,y4 = -100,100
#绘制折线
>>>turtle.penup()
>>>turtle.goto(x1,y1)
>>>turtle.pendown()
>>>turtle.goto(x2,y2)
>>>turtle.goto(x3,y3)
>>>turtle.goto(x4,y4)
#计算起始点和终点的距离
>>>distance = math.sqrt((x1-x4)**2 + (y1-y4)**2)
>>>turtle.write(distance)

运行结果：

14.布尔值

Python2 中没有布尔值，直接用数字 0 表示 False,用数字 1 表示 True。

Python3 中，把 True 和 False 定义成了关键字，但他们的本质还是 1 和 0，甚至可以和数

字相加。

>>> a = True
>>> b = 3
>>> a+b
4

15.比较运算符

所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。

以下假设变量 a 为 15，变量 b 为 30：

 

 16.逻辑运算符

17.同一运算符

同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址。

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个，既比较对象的地址。

== 用于判断引用变量引用对象的值是否相等，默认 调用对象的 __eq__()方法。

18.整数缓存问题

Python 仅仅对比较小的整数对象进行缓存（范围为[-5, 256]）缓存起来，而并非是所有整数对象。需要注意的是，这仅仅是在命令行中执行，而在 Pycharm 或者保存为文件执行，结果是不一样 的，这是因为解释器做了一部分优化(范围是[-5,任意正整数])。

19.总结

1、is 比较两个对象的 id 值是否相等，是否指向同一个内存地址；

2、== 比较的是两个对象的内容是否相等，值是否相等；

3、小整数对象[-5,256]在全局解释器范围内被放入缓存供重复使用；

4、is 运算符比 == 效率高，在变量和 None 进行比较时，应该使用 is。

【操作】同一运算符测试

>>> a = 1000
>>> b = 1000
>>> a == b
True
>>> a is b
False
>>> id(a)
46764560
>>> id(b)
46765216
>>> c = 10
>>> d = 10
>>> c is d
True
>>> id(c)
1388831648
>>> id(d)
1388831648

20.其他基本运算符

20.1比较运算符可以连用，并且含义和我们日常使用完全一致。

>>> a = 4
>>> 3

20.2位操作

>>> a = 0b11001
>>> b = 0b01000
>>> c = a|b
>>> bin(c)
#bin()可以将数字转成二进制表示
'0b11001'
>>> bin(c&b)
'0b1000'
>>> bin(c^b)
'0b10001'
>>> a = 3
>>> a<<2
#左移 1 位相当于乘以 2，左移 2 位，相当于乘以 4
12
>>> a = 8
>>> a>>1
#右移 1 位相当于除以 2

.

20.3加法操作

20.3.1数字相加

3+2 ==> 5

20.3.2字符串拼接

“3”+“2”==> “32”

20.3.3列表、元组等合并

[10,20,30]+[5,10,100] ==>[10,20,30,5,10,100]

20.3.4乘法操作

(1) 数字相乘

3*2 ==> 6

(2) 字符串复制

“sxt”*3 ==> ”sxtsxtsxt”

(3) 列表、元组等复制

[10,20,30]*3 ==> [10,20,30,10,20,30,10,20,30]

21.复合赋值运算符

复合赋值可以让程序更加精炼，提高效率。

注：与 C 和 JAVA 不一样，Python 不支持自增(++)和自减(--)

22.运算符优先级问题

如下优先级，从高到低。

实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织。

1. 乘除优先加减

2. 位运算和算术运算>比较运算符>赋值运算符>逻辑运算符

字符串

1.字符串基本特点

很多人初学编程时，总是担心自己数学不行，潜意识里认为数学好才能编程。实际上，

大多数程序员打交道最多的是“字符串”而不是“数字”。因为，编程是用来解决现实问题

的，因此逻辑思维的重要性远远超过数学能力。

字符串的本质是：字符序列。Python 的字符串是不可变的，我们无法对原字符串做任

何修改。但，可以将字符串的一部分复制到新创建的字符串，达到“看起来修改”的效果。

Python 不支持单字符类型，单字符也是作为一个字符串使用的。

2.字符串的编码

Python3 直接支持 Unicode，可以表示世界上任何书面语言的字符。Python3 的字符

默认就是 16 位 Unicode 编码，ASCII 码是 Unicode 编码的子集。

使用内置函数 ord()可以把字符转换成对应的 Unicode 码；

使用内置函数 chr()可以把十进制数字转换成对应的字符。

>>> ord('A')
65
>>> ord('高')
39640
>>> chr(66)
'B'
>>> ord('淇')
28103

3.引号创建字符串

我们可以通过单引号或双引号创建字符串。例如：a=’abc’; b=”sxt”

使用两种引号的好处是可以创建本身就包含引号的字符串，而不用使用转义字符。例如：

>>> a = "I'm a teacher!"
>>> print(a)
I'm a teacher!
>>> b = 'my_name is "TOM"'
>>> print(b)
my_name is "TOM"

连续三个单引号或三个双引号，可以帮助我们创建多行字符串。例如：

>>> resume = ''' name="gaoqi"
company="sxt"
age=18
lover="Tom"'''
>>> print(resume)
name="gaoqi"
company="sxt"
age=18
lover="Tom"

4.空字符串和 len()函数

Python 允许空字符串的存在，不包含任何字符且长度为 0。例如：

>>> c = ''
>>> len(c)
0
len()用于计算字符串含有多少字符。例如：
>>> d = 'abc 尚学堂'
>>> len(d)
6

5.转义字符

我们可以使用“

\+特殊字符”，实现某些难以用字符表示的效果。比如：换行等。常见的转义字符有这些：

【操作】测试转义字符的使用

>>> a = 'I\nlove\nU'
>>> a
'I\nlove\nU'
>>> print(a)
I
love
U
>>> print('aaabb\
cccddd')
aaabbcccddd

6.字符串拼接

6.1可以使用+将多个字符串拼接起来。例如：’aa’+ ’bb’ ==>’aabb’。

(1) 如果+两边都是字符串，则拼接。

(2) 如果+两边都是数字，则加法运算。

(3) 如果+两边类型不同，则抛出异常。

6.2可以将多个字面字符串直接放到一起实现拼接。例如：’aa’’bb’==>’aabb’

【操作】字符串拼接操作

>>> a = 'sxt'+'gaoqi'
>>> a
'sxtgaoqi'
>>> b = 'sxt''gaoqi'
>>> b
'sxtgaoqi'

7.字符串复制

使用*可以实现字符串复制。

【操作】字符串复制操作

>>> a = 'Sxt'*3
>>> a
'SxtSxtSxt'

8.不换行打印

我们前面调用 print 时，会自动打印一个换行符。有时，我们不想换行，不想自动添加换行

符。我们可以自己通过参数 end = “任意字符串”。实现末尾添加任何内容：

建立源文件 mypy_06.py：

print("sxt",end=' ')

print("sxt",end='##')

print("sxt")

运行结果：

sxt sxt##sxt

9.从控制台读取字符串

我们可以使用 input()从控制台读取键盘输入的内容。

>>> myname = input("请输入名字:")
请输入名字:高淇
>>> myname
'高淇'

10.str()实现数字转型字符串

str()可以帮助我们将其他数据类型转换为字符串。例如：

str(5.20) ==> ‘5.20’

str(3.14e2)==>’314.0’

str(True) ==> ‘True’

当我们调用 print()函数时，解释器自动调用了 str()将非字符串的对象转成了字符串。我们

在面向对象章节中详细讲解这部分内容。

11.使用[]提取字符

字符串的本质就是字符序列，我们可以通过在字符串后面添加[]，在[]里面指定偏移量， 可以提取该位置的单个字符。

正向搜索：

最左侧第一个字符，偏移量是 0，第二个偏移量是 1，以此类推。直到 len(str)-1 为止。

反向搜索：

最右侧第一个字符，偏移量是-1，倒数第二个偏移量是-2，以此类推，直到-len(str) 为止。

【操作】使用[]提取字符串中的字符

>>> a = 'abcdefghijklmnopqrstuvwxyz'
>>> a
'abcdefghijklmnopqrstuvwxyz'
>>> a[0]
'a'
>>> a[3]
'd'
>>> a[26-1]
'z'
>>> a[-1]
'z'
>>> a[-26]
'a'
>>> a[-30]
Traceback (most recent call last):
File "", line 1, in 
a[-30]
IndexError: string index out of range

12.replace()实现字符串替换

字符串是“不可改变”的，我们通过[]可以获取字符串指定位置的字符，但是我们不能改变

字符串。我们尝试改变字符串中某个字符，发现报错了：

>>> a = 'abcdefghijklmnopqrstuvwxyz'
>>> a
'abcdefghijklmnopqrstuvwxyz'
>>> a[3]='高'
Traceback (most recent call last):
File "", line 1, in 
a[3]='高'
TypeError: 'str' object does not support item assignment

字符串不可改变。但是，我们确实有时候需要替换某些字符。这时，只能通过创建新的字符串来实现。

>>> a = 'abcdefghijklmnopqrstuvwxyz'
>>> a
'abcdefghijklmnopqrstuvwxyz'
>>> a = a.replace('c','高')
'ab 高 defghijklmnopqrstuvwxyz'

整个过程中，实际上我们是创建了新的字符串对象，并指向了变量 a，而不是修改了以前的

字符串。 内存图如下：

13.字符串切片 slice 操作

切片 slice 操作可以让我们快速的提取子字符串。标准格式为：

[起始偏移量 start：终止偏移量 end：步长 step]

典型操作(三个量为正数的情况)如下：

其他操作（三个量为负数）的情况：

切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起始偏移量小于 0 则会当做 0，终止偏移量大于“长度-1”会被当成-1。例如：

>>> "abcdefg"[3:50]
'defg'

我们发现正常输出了结果，没有报错。

【操作】

1. 将”to be or not to be”字符串倒序输出

2. 将”sxtsxtsxtsxtsxt”字符串中所有的 s 输出

14.split()分割和 join()合并

split()可以基于指定分隔符将字符串分隔成多个子字符串(存储到列表中)。如果不指定分隔符，则默认使用空白字符(换行符/空格/制表符)。示例代码如下：

>>> a = "to be or not to be"
>>> a.split()
['to', 'be', 'or', 'not', 'to', 'be']
>>> a.split('be')
['to ', ' or not to ', '']
join()的作用和 split()作用刚好相反，用于将一系列子字符串连接起来。示例代码如下：
>>> a = ['sxt','sxt100','sxt200']
>>> '*'.join(a)
'sxt*sxt100*sxt200'

15.拼接字符串要点：

使用字符串拼接符+，会生成新的字符串对象，因此不推荐使用+来拼接字符串。推荐使用 join 函数，因为 join 函数在拼接字符串之前会计算所有字符串的长度，然后逐一拷贝，

仅新建一次对象。

【操作】测试+拼接符和 join()，不同的效率 (mypy_07.py)

import time

time01 = time.time() #起始时刻

a = ""

for i in range(1000000):

a += "sxt"

time02 = time.time()

#终止时刻

print("运算时间："+str(time02-time01))

time03 = time.time()

#起始时刻

li = []

for i in range(1000000):

li.append("sxt")

a = "".join(li)

time04 = time.time()

#终止时刻

print("运算时间："+str(time04-time03))

16.字符串驻留机制和字符串比较

字符串驻留： 仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。

Python 支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线（_）、字母和数字）会启用字符串驻留机制驻留机制。

>>> a = "abd_33"
>>> b = "abd_33"
>>> a is b
True
>>> c = "dd#"
>>> d = "dd#"
>>> c is d
False
>>> str1 = "aa"
>>> str2 = "bb"
>>> str1+str2 is "aabb"
False
>>> str1+str2 == "aabb"
True

17.字符串比较和同一性

我们可以直接使用==,!=对字符串进行比较，是否含有相同的字符。

我们使用 is / not is，判断两个对象是否同一个对象。比较的是对象的地址，即 id(obj1)是

否和 id(obj2)相等。

18.成员操作符

in /not in 关键字，判断某个字符(子字符串)是否存在于字符串中。

19.字符串常用方法汇总

字符串有很多常用的方法，我们需要熟悉。我们通过表格将这些方法汇总起来，方便大家查

阅。希望大家针对每个方法都做一次测试。

20.常用查找方法

以一段文本作为测试：

a='''我是高淇,今年 18 岁了,我在北京尚学堂科技上班。我的儿子叫高洛希，他 6 岁了。我

是一个编程教育的普及者，希望影响 6000 万学习编程的中国人。我儿子现在也开始学习编

程，希望他 18 岁的时候可以超过我'''

21.去除首尾信息

我们可以通过 strip()去除字符串首尾指定信息。通过 lstrip()去除字符串左边指定信息，

rstrip()去除字符串右边指定信息。

【操作】去除字符串首尾信息

>>> "*s*x*t*".strip("*")
's*x*t'
>>> "*s*x*t*".lstrip("*")
's*x*t*'
>>> "*s*x*t*".rstrip("*")
'*s*x*t'
>>> " sxt ".strip()
'sxt'

22.大小写转换

编程中关于字符串大小写转换的情况，经常遇到。我们将相关方法汇总到这里。为了方便学

习，先设定一个测试变量：

a = "gaoqi love programming, love SXT"

23.格式排版

center()、ljust()、rjust()这三个函数用于对字符串实现排版。示例如下：

>>> a="SXT"
>>> a.center(10,"*")
'***SXT****'
>>> a.center(10)
' SXT '
>>> a.ljust(10,"*")
'SXT*******'

24.其他方法

1. isalnum() 是否为字母或数字

2. isalpha() 检测字符串是否只由字母组成(含汉字)。

3. isdigit() 检测字符串是否只由数字组成。

4. isspace() 检测是否为空白符

5. isupper() 是否为大写字母

6. islower() 是否为小写字母

>>> "sxt100".isalnum()
True
>>> "sxt 尚学堂".isalpha()
True
>>> "234.3".isdigit()
False
>>> "23423".isdigit()
True
>>> "aB".isupper()
False
>>> "A".isupper()
True
>>> "\t\n".isspace()
True

25.字符串的格式化

format()基本用法

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

format 函数可以接受不限个参数，位置可以不按顺序。

我们通过示例进行格式化的学习。

>>> a = "名字是:{0},年龄是:{1}"
>>> a.format("高淇",18)
'名字是:高淇,年龄是：18'
>>> a.format("高希希",6)
'名字是:高希希,年龄是：6'
>>> b = "名字是：
{0}，年龄是{1}。{0}是个好小伙"
>>> b.format("高淇",18)
'名字是：高淇，年龄是 18。高淇是个好小伙'
>>> c = "名字是{name}，年龄是{age}"
>>> c.format(age=19,name='高淇')
'名字是高淇，年龄是 19'

我们可以通过{索引}/{参数名}，直接映射参数值，实现对字符串的格式化，非常方便。

填充与对齐

填充常跟对齐一起使用

^、<、>分别是居中、左对齐、右对齐，后面带宽度

:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充

>>> "{:*>8}".format("245")

'*****245'

>>> "我是{0},我喜欢数字{1:*^8}".format("高淇","666")

'我是高淇,我喜欢数字**666***'

数字格式化

浮点数通过 f，整数通过 d 进行需要的格式化。案例如下：

>>> a = "我是{0}，我的存款有{1:.2f}"

>>> a.format("高淇",3888.234342)

'我是高淇，我的存款有 3888.23'

其他格式，供大家参考：

第一章

本章实操作业

1. 根据老师代码，完成奥运五环的绘图程序

>>>import turtle
>>>turtle.showturtle()
>>>turtle.width(10)
>>>turtle.color("blue")
>>>turtle.circle(50)
>>>turtle.penup()
>>>turtle.goto(120,0)
>>>turtle.pendown()
>>>turtle.color("black")
>>>turtle.circle(50)
>>>turtle.penup()
>>>turtle.goto(240,0)
>>>turtle.pendown()
>>>turtle.color("red")
>>>turtle.circle(50)
>>>turtle.penup()
>>>turtle.goto(60,-50)
>>>turtle.pendown()
>>>turtle.color("yellow")
>>>turtle.circle(50)
>>>turtle.penup()
>>>turtle.goto(180,-50)
>>>turtle.pendown()
>>>turtle.color("green")
>>>turtle.circle(50)

 

2. 使用海龟绘图，输出四个矩形

>>>import turtle
>>>turtle.showturtle()
>>>turtle.goto(100,0)
>>>turtle.goto(100,100)
>>>turtle.goto(0,100)
>>>turtle.goto(0,0)
>>>turtle.penup()
>>>turtle.goto(120,0)
>>>turtle.pendown()
>>>turtle.goto(220,0)
>>>turtle.goto(220,100)
>>>turtle.goto(120,100)
>>>turtle.goto(120,0)
>>>turtle.penup()
>>>turtle.goto(120,-20)
>>>turtle.pendown()
>>>turtle.goto(220,-20)
>>>turtle.goto(220,-120)
>>>turtle.goto(120,-120)
>>>turtle.goto(120,-20)
>>>turtle.penup()
>>>turtle.goto(0,-20)
>>>turtle.pendown()
>>>turtle.goto(100,-20)
>>>turtle.goto(100,-120)
>>>turtle.goto(0,-120)
>>>turtle.goto(0,-20)

第二章

本章实操作业

1. 使用 python 表示数学式： 

(5+10*x)/5-13*(y-1)*(a+b)/x+9*(5/x+(12+x)/y)

 

2. 从控制台输入用户的月薪，进行运算计算出年薪。打印输出用户的年薪

 

3. 使用字符串复制，用计算机打印出“爱你一百遍”，打印 100 次

>>> a='我爱你'*100
>>> print(a)
我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你我爱你
>>> 

3. 将”to be or not to be”字符串倒序输出

>>> "to be or not to be"[::-1]
'eb ot ton ro eb ot'

4. 将”sxtsxtsxtsxtsxt”字符串中所有的 s 输出

>>> 'sxtsxtsxtsxt'[::3]
'ssss'

5. 判断如下输出结果，并文字解释原因：

>>> a = "abd_33"

>>> b = "abd_33"

>>> c = "dd#"

>>> d = "dd#"

>>> a is b

#输出 true or false?

True，Python 支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线（_）、字母和数字）会启用字符串驻留机制驻留机制，两次调用的id相同。

>>> c is d

#输出 true or false?

False，#是不符合标识符规则的字符串（仅包含下划线（_）、字母和数字）。

6. 写出如下代码打印的结果：

>>> c = "名字是{name}，年龄是{age}"

>>> c.format(age=19,name='高淇')

'名字是高淇，年龄是 19'