Python基础学习day2

链式赋值

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

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

系列解包赋值

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

>>>a,b,c=4,5,6 相当于:a=4;b=5;c=6

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

常量

Python不支持常量，既没有语法规则限制改变一个常量的值。我们只能约定常量的命名规则，以及在程序的逻辑上不对常量的值做出修改（Java中常量的值不变，Python中可以任意修改）

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

最基本内置数据类型介绍

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

1. 整型

  整数,2345,10,50

1. 浮点型

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

1. 布尔型

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

1. 字符串型

  由字符串组成的序列。“abc”，“sxt”“程序员”

数字

符串Python支持整数（如：50,520）和浮点数（如：3.14，10.0,1.23e2），我们可以对数字做如下运算。

除数为0，会产生异常：

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

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

整数

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

（十进制逢十进一，二进制逢二进一）

二进制	十进制
0	0
1	1
2	10
3	11
4	100
5	101
6	110
7	111
8	1000

十进制	八进制
0-7	0-7
8	10
9	11
10	12（1*8^1+2*8^0）

十进制	十六进制
1	1
9	9
10-15	a-e
16	10

这三种进制可以非常方便的进行“位运算”操作。

操作：

0b101 #二进制
5
0o10  #八进制
8
0xf   #十六进制
15
0x255 #十六进制
597
0xff #十六进制
255

使用int()实现类型转换

1. 浮点数直接舍去小数部分。如：int（9,9）结果是：9
2. 布尔值True转为1，False转为0.如int（True）结果是1
3. 字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错

操作：

int(3.1415)
3
int(True)
1
int('234')
234
int('123a')
Traceback (most recent call last):
  File "<pyshell#12>", line 1, in <module>
    int('123a')
ValueError: invalid literal for int() with base 10: '123a'

自动转型：

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

整数可以有多大？

浮点数

>>>Float（3）

3.0

>>>314E-2

3.14

类型转换和四舍五入

>>>round(3.14)

3

增强型赋值运算

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

a=a+1等价于： a+=1

 注意：‘+=’中间不能加空格

时间的表示

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

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

import time
time.time()
1639470499.214558 #从1970到现在多少秒
b=int(time.time())
b
1639470522
totalMinutes = b//60 #从1970到现在过了多少分钟
totalMinutes
27324508
totalHours = totalMinutes//60 #从1970到现在过了多少小时
totalHours
455408
totalDays = totalHours//24 #从1970到现在过了多少天
totalDays
18975
totalYears = totalDays//365 #从1970到现在过了多少年
totalYears
51

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

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)

结果：

比较运算符

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

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

 逻辑运算符

运算符	格式	说明
Or 逻辑或	x or y	x为true，则不计算y，直接返回true x为false，则返回y
and 逻辑与	x and y	x为true，则返回y的值 x为false，则不计算y直接返回false
not 逻辑非	not x	x为true，返回false x为false，返回true

a=True
b = False
a or 30
True
b or 30
30
a or 30/0
True
b or a
True

同一运算符

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

运算符	描述
is	is是判断两个标识符是不是引用同一个对象
is not	Is not 是判断两个标识符是不是引用不同对象

is 与 == 区别：

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

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

a =1000
b= 1000
a == b
True
a is b
False
id(a)
2307782748304
id(b)
2307782748336
#a和b值一样，但不是同一个对象
a is not b
True

整数缓存问题

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

#在文件中执行的情况下
x = -6
y = -6
print(x is y)
False #-6不在缓存范围内，所以a和b不是同一个对象false


x = -5
y = -5
print(x is y)
True #-5在范围内，所以解释器会先把-5缓存起来，下次直接调用，所以True

x=1000001
y=1000001
print(x is y)
True  #1000001属于缓存范围内，所以第二次直接调用

总结  （一个完整对象三个部分id，类型，value）

1. is 比较两个对象的id值是否相等，是否指向同一个内存地址
2. ==比较的是两个对象的内容是否相等，值是否相等
3. 小整数对象[-5,256]在全局解释器范围内被放入缓存供重复使用
4. is运算符比==效率高，在变量和None进行比较时，应该用is（因为is是直接比较，==需要调用方法）

字符串

字符串的本质是：字符序列。Python的字符串是不可变的，我们无法对原字符串做任何修改。但，可以将字符串的一部分复制到新创建的字符串，达到“看起来修改”的效果。

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

字符串的编码

（Unicode之前用的是ASCII码）

引号创建字符串

我们可以通过单引号或双引号创建字符串。例如：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'

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

空字符串和len（）函数

Python允许空字符串的存在，不包含任何字符且长度为0（空格也不行）

例如：

>>>c=’’

>>>len(c)

0

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

>>>d=’abc程序员’

>>>len(d)

6

转义字符

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

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

字符串拼接

字符串复制

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

【操作】字符串复制操作

>>>a=’Sxt*3’

>>>a

‘SxtSxtSxt’

不换行打印

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

>>>print(“sxt”,end=’’)

>>>print(“sxt”,end=’##’)

>>>print(“sxt”)

运行结果：

sxt sxt##sxt

从控制台读取字符串

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

>>>myname=input(‘请输入名字:’)

请输入名字：张三

>>>myname

‘张三’

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

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

str(5.20)==>’5.20’ str(3.14e2)==>’314.0’ str(True)==>’True’

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

使用[]提取字符

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

     正向搜索：

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

     反向搜索：

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

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

>>>a='abcdefgqweqw'
>>>a
'abcdefgqweqw'
>>>a[0]
'a'
>>>a[3]
'd'
>>>a[6-1]
'f'
>>>a[-1]
'w'
>>>a[-5]
'q'
>>>a[-30]
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    a[-30]
IndexError: string index out of range

replace()实现字符串替换

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

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

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

>>>a='abcdefgqweqw'
>>>a
'abcdefgqweqw'
>>>a.replace('c','高')
'ab高defgh'
>>>a         #实际并没有改变字符串a，是修改了一个新的字符串对象
'abcdefgh'
>>>b= a.replace('a','高')
b
'高bcdefgh'
>>>a
'abcdefgh'

字符串切片slice操作

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

[起始偏移量start:终止偏移量end:步长step]（默认步长为1）

典型操作（三个量为正数的情况）：

 

切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。

起始偏移量小于0时则会当做0，终止偏移量大于“长度-1”会被当成-1

例：>>>“abcdefg”[3:50]

‘defg’

练习：

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

>>>”to be or not to be”[::-1]

1. 将”sxtsxtsxtsxt”字符串中的所有s输出

>>>”sxtsxtsxtsxt”[::3]

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=['我','来','了']

>>>'*'.join(a)

'我*来*了'

拼接字符串要点：

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

【操作】测试+拼接和join（）用时

注意：避免使用第一类代码，耗时过多，效率过低

字符串比较和同一性

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

我们使用is/not is，判断两个对象是否同一个对象，比较的是对象的地址，即id（obj1）和id（obj2）相等

成员操作符

Is/ not in 关键字，判断某个字符（子字符串）是否存在于字符串中

字符串常用查找方法

以一段文本作为测试：

去除首尾信息

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

>>>'*s*x*t'.strip('*')

's*x*t'

>>>'*s*x*t'.lstrip('*')

's*x*t'

>>>'*s*x*t'.rstrip('*')

'*s*x*t'

大小写转换

测试变量：a=”gaoqi love programming,love SXT”

 

>>>a= "gaoqi love programming,love SXT"

>>>a.capitalize()

'Gaoqi love programming,love sxt'

>>>a.title()

'Gaoqi Love Programming,Love Sxt'

>>>a.upper()

'GAOQI LOVE PROGRAMMING,LOVE SXT'

>>>a.lower()

'gaoqi love programming,love sxt'

>>>a.swapcase()

'GAOQI LOVE PROGRAMMING,LOVE sxt'

格式排版

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

>>>a='SXT'

>>>a.center(10,'*')

'***SXT****'

>>>a.center(10)

'   SXT    '

>>>a.ljust(10,'*')

'SXT*******'

其他方法

字符串的格式化

format()基本用法

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

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

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

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

>>>a="名字是：{0},年龄是:{1}"

>>>a.format("高崎",18)

'名字是：高崎,年龄是:18'
>>>a.format("高老三",10)

'名字是：高老三,年龄是:10'

>>>b="名字是：{0},年龄是:{1} {0}是个好小伙"

>>>b.format('张老二',18)

'名字是：张老二,年龄是:18 张老二是个好小伙'

>>>c="名字是：{name},年龄是:{age}"

>>>c.format(age=19,name='王老五')

'名字是：王老五,年龄是:19'

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

填充与对齐

填充常跟对齐一起使用

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

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

>>>"{:*>8}".format("123")  #8代表*****123总共8个字符

'*****123'

>>>"我是{0},我喜欢数字{1:*^8}".format('豆浆油条','666')

'我是豆浆油条,我喜欢数字**666***'

数字格式化

浮点数通过.f，整数通过.d进行需要的格式化。案例如下：（填充格式基础上多个.）

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

>>>a.format('马爸爸',131231.2345)

'我是马爸爸,我的存款有131231.23'

其他格式