第二节笔记

一、链式赋值

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

x=y=123 #相当于：x=123;y=123
print(x)
print(y)

二、系列解包赋值

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

a,b,c=4,5,6 #相当于：a=4;b=5;c=6
print(a,b,c)
a,b=1,2
a,b=b,a
print(a,b)

三、常量

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

MAX_SPEED=120
print(MAX_SPEED)

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

四、最基本内置数据类型和运算符

每个对象都有类型，python中最基本的内置数据类型：

1.整型

整数： 2345，10,50

2. 浮点型

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

3. 布尔型

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

4. 字符串型

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

五、数字和基本运算符

Python 支持整数和浮点数，我们可以对数学做出如下运算

a=7/2 #浮点数除法 
print(a)

b=7//2 #整数除法
print(b)

c=7%2
print(c) #模（取余)

d=2**3 #幂
print(d)

f=divmod(10,5)# 同时给出商和余数
print(f)

g=divmod(10,3)
print(g)

i=3/0 #除数为0会产生异常
print(i)

六、 整数

Python中，除10进制，还有其他三种进制：
① 0b或0B，二进制 0 1
② 0o或0O，八进制 0 1 2 3 4 5 6 7
③ 0x或0X，十六进制 0 1 2 3 4 5 6 7 8 9 a b c d e f

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

>>> int(9.9)
9
>>> int("456")
456
>>> int("456abc")#字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错。
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    int("456abc")#字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错。
ValueError: invalid literal for int() with base 10: '456abc'
>>> int("456.78")#字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错。
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    int("456.78")#字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错。
ValueError: invalid literal for int() with base 10: '456.78'
>>> 

注意 int(“456.78”)为字符串，因为有“”，但int(9.9),9.9为浮点数。

2. 自动类型

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

>>> 2+8.0
10.0
>>> 

3.整数可以有多大

Python3中，int可以存储任意大小的整数，long被取消。我们甚至可以存储下面的值：

>>> googol=10**100
>>> googol
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

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

七、浮点数

浮点数，称为float。
浮点数用 $a\times b^{10}$ 形式的科学技术发表示。比如：3.14，表示为314E-2或者314e-2.

八、类型转换和四舍五入

1. 类似于int(),我们也可以使用float()将其他类型转换为浮点数。
2. 整数和浮点数混合运算时，表达式结果自动转型成为浮点数。

>>> 2+8.0
10.0
>>> 

3. round(value)可以返回四舍五入的值
   注：但不会改变原有值，而是产生新的值。

九、增强型幅值运算符

十、时间的表示

Python 中可以通过time.time()获得当前时刻，返回的值也 是以秒为单位，带微妙精度的浮点值。
计算机中试件的表示是从“1970年1月1日00:00:00”开始，以毫秒（1/1000秒）进行计算。

>>> import time
>>> b=int(time.time())
>>> b
1608607237
>>> totalMinutes=b/60
>>> totalMinutes
26810120.616666667
>>> totalMinutes=b//60
>>> totalMinutes
26810120
>>> totalHours=totalMinutes//60
>>> tootalHours
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    tootalHours
NameError: name 'tootalHours' is not defined
>>> totalHours
446835
>>> totalDays=totalHours//24
>>> totalDays
18618
>>> totalYears=totalDays//365
>>> totalYears
51
>>> 

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

import turtle
import math

#定义多个点的坐标

x1,y1=100,100
x2,y2=100,-100
x3,y3=-100,-100
x4,y4=-100,100

#绘制折线

turtle.goto(x1,y1)
turtle.goto(x2,y2)
turtle.goto(x3,y3)
turtle.goto(x4,y4)

#计算起始点和终点的距离

distance=math.sqrt((x1-x4)**2+(y1-y4)**2)
turtle.write(distance)

十一、布尔值

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

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

十二、比较运算符

所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。
以下假设变量 a 为 15，变量 b 为 30：

>>> a=15
>>> b=30
>>> a==b
False
>>> a!=b
True
>>> a>b
False
>>> a<b
True
>>> a>=b
False
>>> a<=b
True
>>> 

十二、逻辑运算符

>>> a=True
>>> b=False
>>> a or b
True
>>> a and b
False
>>> not a
False
>>> x=False
>>> y=True
>>> x or y
True
>>> x and y
False
>>> not x
True
>>> 

十三、同一运算符

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

is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个，既比较对象的地址。
== 用于判断引用变量引用对象的值是否相等，默认调用对象的 eq()方法。

十四、整数缓存问题

Python 仅仅对比较小的整数对象进行缓存（范围为[-5, 256]）缓存起来，而并非是所有整数对
象。需要注意的是，这仅仅是在命令行中执行，而在 Pycharm 或者保存为文件执行，结果是不一样
的，这是因为解释器做了一部分优化(范围是[-5,任意正整数])。
·总结
1、is 比较两个对象的 id 值是否相等，是否指向同一个内存地址；
2、== 比较的是两个对象的内容是否相等，值是否相等；
3、小整数对象[-5,256]在全局解释器范围内被放入缓存供重复使用；
4、is 运算符比 == 效率高，在变量和 None 进行比较时，应该使用 is。
【操作】同一运算符测试

>>> a=1000
>>> b=1000
>>> a==b
True
>>> a is b
False
>>> id(a)
2672853335728
>>> id(b)
2672853335504
>>> value(a)
Traceback (most recent call last):
  File "<pyshell#39>", line 1, in <module>
    value(a)
NameError: name 'value' is not defined
>>> c=10
>>> d=10
>>> c is d
True
>>> id(c)
140708533936816
>>> id(d)
140708533936816

基本运算符

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

>>> a = 4
>>> 3<a<10 #关系运算符可以连用

2. 位操作

>>> a = 3
>>> a<<2 #左移 1 位相当于乘以 2.左移 2 位，相当于乘以 4
12
>>> a = 8
>>> a>>2 #右移 1 位相当于除以 2.

3. 加法操作

>>> 3+2 # 数字相加 
5
>>> "3"+"2" #字符串拼接 
'32'
>>> [10,20,30]+[5,10,100] #列表、元组等合并 
[10, 20, 30, 5, 10, 100]

4. 乘法操作

>>> 3*2 # 数字相乘 
6
>>> "sxt"*3 # 字符串复制 
'sxtsxtsxt'
>>> [10,20,30]*3 # 列表、元组等复制
[10, 20, 30, 10, 20, 30, 10, 20, 30]
>>> 

十五、复合赋值运算符

十六、运算符优先级问题

如下优先级，从高到低。

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

1. 乘除优先加减
2. 位运算和算术运算>比较运算符>赋值运算符>逻辑运算符

第二章（2）字符串

一、字符串的编码

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

>>> ord('郝')
37085
>>> ord('帅')
24069
>>> chr(77)
'M'
>>> 

二、引号创建字符串

我们可以通过单引号或双引号创建字符串。例如：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 = "PP"
company="XAUAT" age=35
lover = "turtle" '''
>>> print(resume)
name = "PP"
company="XAUAT" age=35
lover = "turtle" 
>>> 

三、空间字符串和len()函数

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

>>> c=''
>>> len(c)
0

len()用于计算字符串含有多少字符。例如：

>>> d="ppsturtle"
>>> len(d)
9

四、转义字符

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

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

>>> a = "I\nlove\nyou"
>>> a
'I\nlove\nyou'
>>> print(a)
I
love
you
>>> print('aaa\
bbbcccc')
aaabbbcccc
>>> 

五、字符串拼接

1. 可以使用+将多个字符串拼接起来。例如：’aa’+ ’bb’ ==>’aabb’。
   (1) 如果+两边都是字符串，则拼接。
   (2) 如果+两边都是数字，则加法运算。
   (3) 如果+两边类型不同，则抛出异常。
2. 可以将多个字面字符串直接放到一起实现拼接。例如：’aa’’bb’==>’aabb’
   【操作】字符串拼接操作

>>> a='HS'+'WD'
>>> a
'HSWD'
>>> b='HS''WD'
>>> b
'HSWD'

六、字符串复制

使用*可以实现字符串复制。
【操作】字符串复制操作

>>> a="HS"*3
>>> a
'HSHSHS'

七、不换行打印

我们前面调用 print 时，会自动打印一个换行符。有时，我们不想换行，不想自动添加换行符。我们可以自己通过参数 end = “任意字符串”。实现末尾添加任何内容：

>>> print('spp')
spp
>>> print('spp',end='wbd')
sppwbd

八、从控制台读取字符串

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

>>> myname = input("请输入名字")
请输入名字spp
>>> myname
'spp'

九、str()实现数字转型字符串

十、使用[]提取字符

字符串的本质就是字符序列，我们可以通过在字符串后面添加[]，在[]里面指定偏移量，可以提取该位置的单个字符。
正向搜索：最左侧第一个字符，偏移量是 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 "<pyshell#130>", line 1, in <module>
    a[-30]
IndexError: string index out of range
>>> 

十、replace()实现字符串替换

字符串是“不可改变”的，我们通过[]可以获取字符串指定位置的字符，但是我们不能改变字符串。我们尝试改变字符串中某个字符，发现报错了

>>> a = 'abcdefghijklmnopqrstuvwxyz'
>>> a
'abcdefghijklmnopqrstuvwxyz'
>>> a[3]='高'

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

>>> a = 'abcdefghijklmnopqrstuvwxyz'
>>> a
'abcdefghijklmnopqrstuvwxyz'
>>> a=a.replace('c','WB')
>>> a
'abWBdefghijklmnopqrstuvwxyz'
>>> 

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

十一、字符串切片 slice 操作

切片 slice 操作可以让我们快速的提取子字符串。标准格式为：
[起始偏移量 start：终止偏移量 end：步长 step]
典型操作(三个量为正数的情况)如下：

>>> "abcdefg"[3:50]
'defg'
>>> "abcdef"[:2]
'ab'
>>> "abcdef"[2:4]
'cd'
>>> "abcdef"[1:5:2]
'bd'

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

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

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

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

1. 将”to be or not to be”字符串倒序输出
2. 2. 将”sxtsxtsxtsxtsxt”字符串中所有的 s 输出

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

十二、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'

拼接字符串要点：
使用字符串拼接符+，会生成新的字符串对象，因此不推荐使用+来拼接字符串。推荐使用 join 函数，因为 join 函数在拼接字符串之前会计算所有字符串的长度，然后逐一拷贝，仅新建一次对象。
【操作】测试+拼接符和 join()，不同的效率 (mypy_08.py)

import time

time01 = time.time() #起始时刻
a = ""
for i in range(1000000):
    a+="sxt" #  最后为 1000000 个 a

time02 = time.time() #终止时刻
print("运算时间：" +str(time02-time01))


time03 = time.time() #起始时刻
li = []
for i in range(1000000):
    li.append("sxt")

a = "".join(li) # 最后为 1 个 a

time04 = time.time() #终止时刻
print("运算时间："+str(time04-time03))

推荐使用joint
a+=“sxt” # 最后为 1000000 个 a
a = “”.join(li) # 最后为 1 个 a

十三、 字符串驻留机制和字符串比较

字符串驻留：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。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

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

十四、字符串比较和同一性

我们可以直接使用==,!=对字符串进行比较，是否含有相同的字符。
我们使用 is / not is，判断两个对象是否同一个对象。比较的是对象的地址，即 id(obj1)是否和 id(obj2)相等。
总结
“==”比较的是值是否相等
“is” 比较的是ID，对象

十五、成员操作符

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

十六、字符串常用方法汇总

常用查找方法
a=’’‘我是高淇,今年 18 岁了,我在北京尚学堂科技上班。我的儿子叫高洛希，他 6 岁了。我是一个编程教育的普及者，希望影响 6000 万学习编程的中国人。我儿子现在也开始学习编程，希望他 18 岁的时候可以超过我’’

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

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

大小写转换
编程中关于字符串大小写转换的情况，经常遇到。我们将相关方法汇总到这里。为了方便学习，先设定一个测试变量：
a = “gaoqi love programming, love SXT”

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

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

其他方法

1. isalnum() 是否为字母或数字
2. isalpha() 检测字符串是否只由字母组成(含汉字)。
3. isdigit() 检测字符串是否只由数字组成。
4. isspace() 检测是否为空白符
5. isupper() 是否为大写字母
6. islower() 是否为小写字母

>>> "sxt100".isalnum()
True
>>> "sxt尚学堂".isalpha()
True
>>> "234.3"isdigit()
SyntaxError: invalid syntax
>>> "234.3".isdigit()
False
>>> "23435".isdigit()
True
>>> "aB".isupper()
False
>>> "A".isupper()
True
>>> "\t\n".isspace()
True

十七、字符串的格式化

format()基本用法
格式化字符串的函数 str.format()，它增强了字符串格式化的
功能。基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。

>>> a = "名字：{0},年龄是：{1}"
>>> a.format("SPP",35)
'名字：SPP,年龄是：35'
>>> a.format("SPPWBD",35)
'名字：SPPWBD,年龄是：35'
>>> b = "名字：[0],年龄是{1},{0}是个好小伙"
>>> b = "名字：{0},年龄是{1},{0}是个好小伙"
>>> b.format("SPPWBD",380)
'名字：SPPWBD,年龄是380,SPPWBD是个好小伙'
>>> c = "名字是{name},年龄是{age}"
>>> c.format(age=38,name="SPP")
'名字是SPP,年龄是38'

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

填充与对齐
填充常跟对齐一起使用
^、<、>分别是居中、左对齐、右对齐，后面带宽度
:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充

>>> "{:*>8}".format("245")
'*****245'
>>> "我是{0},我喜欢数字{1:*^8}".format("SPP","5")
'我是SPP,我喜欢数字***5****'
>>> "我是{name},我喜欢数字{num:*^8}".format(name="SPP",num="5")
'我是SPP,我喜欢数字***5****'

注意{索引}/{参数名}不能夹杂使用

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

>>> a = "我是{0}，我的存款有{1:2f}"
>>> a.format("HS",38885.1255)
'我是HS，我的存款有38885.125500'

其他格式

可变字符串
在 Python 中，字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，智能创建新的字符串对象。但是，经常我们确实需要原地修改字符串，可以使用 io.StringIO对象或 array 模块。

>>> import io
>>> s = "hello, sxt"
>>> sio = io.StringIO(s)
>>> sio
<_io.StringIO object at 0x0000021563EE9CA8>
>>> sio.getvalue()
'hello, sxt'
>>> sio.seek(7)
7
>>> sio.write("g")
1
>>> sio.getvalue()
'hello, gxt'

本章实操作业

1. 使用 python 表示数学式：

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

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

>>> salary=input("请输入年薪:")
请输入年薪:0.1W
>>> salary
'0.1W'

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

>>> a="爱你一万遍"*100
>>> a
'爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍爱你一万遍'

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

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

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

>>> "sxtsxtsxtsxtsxt"[-3:-15:-3]
'ssss'

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

>>> a="abd_33"
>>> b="abd_33"
>>> c="dd#"
>>> d="dd#"
>>> a is b
True
>>> c is d
False

a is b True： 因为符合标识符规则的字符串，都是字母。

c is d False：不符合标识符规则的字符串（仅包含下划线（_）、字母和数字）。
6. 写出如下代码打印的结果：

>>> c = "名字是{name}, 年龄是{age}"
>>> c.format(age=19,name="高琪")
'名字是高琪, 年龄是19'