Python_Day_02

链式赋值

链式赋值用于同一个对象赋值给多个变量。
x = y = 123 相当于 x=123;y = 123

>>> x = y = 123
>>> x
123
>>> y
123
>>> 

系列解包赋值

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

使用系列解包赋值实现变量交换,此处就可以不用中间变量。

>>> a,b = 1,2
>>> a,b = b,a
>>> a
2
>>> b
1

完成同样的功能，实现的代码最少。

常量

Python不支持常量 我们一般通过逻辑上不对常量的值进行修改，但是实际上是可以改的，我们只是逻辑上不进行修改。

>>> SPEED_MAX = 120
>>> print(SPEED_MAX)
120
>>> 

最基本的内置数据类型

每个对象都有数据类型 Python中最基本的内置数据类型:

1. 整型 整数 1，2，3，4
2. 浮点型 小数 3.14
3. 布尔型 真假 True False
4. 字符串型 由字符串组成的序列 “abc” “你好”

特别的计算:
/ : 浮点数除法 8/2 = 4.0 7/2 = 3.5 – 有小数部分
// : 整数除法 7 // 2 = 3
%: 模除 取余 7%4 = 3
: 23 = 8 表示2的3次方

特别的一个方法: divmod()函数可以同时得到商和余数:

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

此表示13 / 3 = 4…1

整数

Python中，除了10进制外，还有三种进制:

• 0b 或者 0B 二进制 0 1
• 0o 或者 0O 八进制 1 2 3 4 5 6 7
• 0x 或者 0X 十六进制 1 2 3 4 5 6 7 8 9 a b c d e f

>>> 12
12
>>> 0b101
5
>>> 0o10
8
>>> 0xff
255
>>> 

展示的是各位进制转化成十进制

利用int()的方法实现类型的转换:

1. 浮点数类型直接舍去小数部分。 如: int(9.9) 结果是: 9
2. 布尔值True转为1 False转为0。如: int(True)结果是1。
3. 字符串符合整数格式(浮点数格式不行) 则直接转为对应整数 否则将会报错

>>> int("123457")
123457
>>> int(True)
1
>>> int(False)
0
>>> int (2.8)
2
>>> 

自动转型

整型＋浮点型混合运算时，表达式结果自动转型为浮点数。 比如: 2 + 8.0 = 10.0

>>> 2 + 8.0
10.0

整数可以有多大?

Python3中 int 可以储存任意大小的整数，所以Python3中可以做超大数的计算，而不会造成"整数溢出" 这也是Python特别适合科学运算的特点。

浮点数:

浮点数(float)
浮点数用科学技术法表示,比如:3.14表示成314E-2或者314e-2，后面代表的是10的-2次方。

类型转换和四舍五入:

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

>>> float(3)
3.0

• 整数(加减乘除)浮点数 = 浮点数
• round(value) 可以返回四舍五入的值 但不会改变原有值 而是产生新的值

>>> round(3.14)
3
>>> round(3.9)
4

增强型赋值运算符

+= -+ *= /= //= **= %=

>>> a = 1
>>> a += 1
>>> a
2

时间的表示

计算机元年: 1970年1月1日，也称为"unix时间点"，以(1/1000秒)进行计算。
Python中可以通过time.time()获得当前时刻,返回的值以秒为单位,带微秒(1/1000毫秒)精度的浮点值。
时间本质上是一个数字。
所以现在的时间是:

>>> import time
>>> time.time()
1585275768.759594
>>> a = True
>>> a
True
>>> b = int(time.time())
>>> b
1585277494
>>> TM = b/60
26421291.566666666
>>> int(TM)
26421291
>>> TM
26421291.566666666
>>> TM = TM/60
>>> TM
440354.8594444444
>>> TM/24
18348.119143518517
>>> TM
440354.8594444444
>>> TM = TM/24
>>> TM
18348.119143518517
>>> TM = TM/365
>>> TM
50.26881957128361
>>> 

操作练习: 定义多点坐标_绘出折现_并计算起始点和终点举例

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)

得出:

布尔值

True和False 他们的本质还是1和0 甚至可以和数字相加。

>>> a = 0
>>> a
0
>>> a+True
1

比较运算符:

> < >= <= != == 对了返回True 错了返回False

逻辑运算符:

or and not

>>> a = 1
>>> b = 0
>>> a or b
1
>>> a and b
0
>>> not a
False

总结:

1. or只要有一个True就是True 。and必须同时为True最后结果才能是True。
2. or运算符中，如果a为false 则返回的是b的值，我感觉像是电路图里的并联。

>>> a = True
>>> b = False
>>> a or 30
True
>>> b or 30
30

3. and运算符中，如果a为True 则返回的是b的值，我感觉像是电路图的串联。

>>> a and 30
30
>>> b and 30
False

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

• is是判断两个标识符是不是引用同一个对象
• is not 是判断两个标识符是不是引用不同的对象

is 和 == 区别:
is 用于判断两个变量引用对象是否为同一个 即比较对象的id地址
== 用于判断两个引用变量引用对象的值是否相等 默认调用对象的__eq__()方法

>>> a = 1000
>>> b = 1000
>>> a == b
True
>>> a is b
False
>>> id(a)
4507091088
>>> id(b)
4507091312
>>> 

==判断的是value，所以返回是True.
但是:

>>> c = 10
>>> d = 10
>>> c is d
True
>>> id(c)
4439186352
>>> id(d)
4439186352

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

• 在IDLE内(交互模式下)作用的范围是[-5,256], 在全局解释器范围内被放入缓存供重复使用,但是超过这个范围会另外立一个对象.
• 但是在高级的解释器内部是[-5,+无穷]
• 比较值以后都用 ==
• 比较是不是同一个对象用 is
• is 运算符比 == 效率高，在变量和None进行比较,应该是使用is

字符串

字符串的本质是: 字符序列，没有字符这个概念，Python的字符串是不可以变的，我们无法对原字符做任何的修改。但是可以将字符串的一部分赋值到新创建的字符串中，达到"看起来修改"的效果。
Python不支持单字字符串，单字符也是作为一个字符串使用的。 “a” 是长度是1的字符串。
Python3使用的是Unicode字符，可以表示世界上任何书面语言的字符，Python3的字符默认就是16位Unicode编码，ASCII码则是Unicode的子集。
使用内置函数ord()可以看到将字符转换成对应的Unicode码。
使用内置函数chr()可以把十进制数字转换成对应的字符。

>>> ord('A')
65
>>> ord('搞')
25630
>>> chr(66)
'B'
>>> chr(92)
'\\'
>>> 

创建字符串:

我们可以通过单引号或者双引号创建字符串。a = "abc" ;b = "sxt"
如果字符串里面是有单引号比如i' m a teacher
那么外面最好用双引号" i' m a teacher "
三引号使用多行字符串:

>>> '''
第一行
第二行
第三行
第四行'''
'\n第一行\n第二行\n第三行\n第四行'
>>> 

空字符串和len()函数:

>>> c = " "
>>> len(c)
1
>>> 

转移字符:

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

转移字符	描述
\	续航符
\	反斜杠符号
’	单引号
"	双引号
\b	退格
\n	换行
\t	横向制表符
\r	回车

"\n"换行符的用法:

>>> a = 'i\nlove\nyou'
>>> a
'i\nlove\nyou'
>>> print(a)
i
love
you
>>> 

\'的用法:

>>> b = 'i\'m a teacher'
>>> b
"i'm a teacher"
>>> 

续航符\的用法:

>>> print("下午\
... 你好")
下午你好
>>>

字符串的拼接:

使用＋进行拼接。
如果两边类型不同，则会抛出异常。
也可以将多个字面字符串直接放到一起实现拼接。
两种方式:

>>> a = 'a'+'b'
>>> a
'ab'
>>> a = 'a'
>>> a
'a'
>>> a = 'a''b'
>>> a
'ab'

做乘法:

>>> "a"*3
'aaa'
>>> 

不换行打印:
如果我们print时，会自动打印一个换行符，有时，我们不想换行，我们可以通过参数end = "任意字符串"。实现末尾添加任意内容:
建立源代码:

print('我是',end="")
print("你",end="~")
print("哥哥")

输出结果: 我是你~哥哥

从控制台输入读取字符串:

myname = input("请输入名字: ")
print(myname)

输出:

请输入名字: 南京
南京

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

>>> str(21)
'21'
>>> str(3.14e2)
'314.0'
>>> 

字符串的本质是字符序列，我们可以通过在字符串后面添加[] 在[]里面可以指定偏移量，可以提取该位置的单个字符。
正向搜索:最左侧0开始，第二个是1，知道len(str)-1
反向搜索:最右面第一个字符,偏移量-1,倒数第二个是-2,直到-len(str)

'edewdwefewfwefegrgth6j65dwdwqd2d23myum'
>>> a[0]
'e'
>>> a[5]
'w'
>>> a[-1]
'm'
>>> a[len(a)-1]
'm'
>>> 
>>> a[-len(a)]
'e'
>>> 

replace()实现字符串替换

>>> a.replace('e','l')
'ldlwdwlflwfwlflgrgth6j65dwdwqd2d23myum'
>>> 

这里其实生成了一个新的字符串，但是a还是

>>> a
'edewdwefewfwefegrgth6j65dwdwqd2d23myum'

但是此时重新赋值时就变了:

>>> a = a.replace('e','r')
>>> a
'rdrwdwrfrwfwrfrgrgth6j65dwdwqd2d23myum'
>>> 

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

字符串切片slice操作

切片slice操作可以让我们快速的提取子字符串，标准格式为:
[起始偏移量start:终止偏移量end:步长]
典型操作:
[:]提取整个字符串
[start:]从一个start开始到结尾
[:end]从开头到此end-1
[start:end]是从start开始到end-1
[start:end:step]是从start开始，到end-1结束，步长是step

>>> a = "abcdefg"
>>> a
'abcdefg'
>>> a[2:]
'cdefg'
>>> a[:2]
'ab'
>>> a[:]
'abcdefg'
>>> a[0:6:2]
'ace'
>>> 

也可以slice切片中加负数。按照负数的法则。
但是记住负数是从-1开始的，不是0, 而且包头不包尾。

>>> a
'ABCDEF'
>>> a[-4:-1]
'CDE'
>>> 

把字符串倒过来也很简单:

>>> a[::-1]
'FEDCBA'
>>> 

split()分割和join()合并

>>> a = "to be or not to be"
>>> a.split() # 默认是按照空白字符(换行符/空格/制表符)
['to', 'be', 'or', 'not', 'to', 'be']
>>> a.split("be") # 按照'be'分割
['to ', ' or not to ', '']
>>> 

join()的作用和split()的作用真好相反:

>>> a = ['你是','我的','优乐美']
>>> '~'.join(a)
'你是~我的~优乐美'
>>> 

下面做一个实验: 看直接字符串之间相+的效率和join()函数的效率哪个快.

import time
start = time.time()
a = ""
for i in range(100000):
    a += "sxt"
end = time.time()
print("运算时间:",(end - start))
start01 = time.time()
list01 = []
for i in range(100000):
    list01.append("sxt")
a = "".join(list01)
end01 = time.time()
print("运算时间:",(end01 - start01))

结果:

运算时间: 0.02559494972229004
运算时间: 0.012558221817016602

为什么呢?因为join函数在用时只是一个对象a，但是不断的字符串之间的+时，就是得生成很对很多对象，就很耗时间。

字符串的驻留机制

Python支持字符串驻留机制，对于符合标识符的字符串(仅包含下划线(_),字母和数字)会启用字符串驻留机制。

>>> a = "abcd_33"
>>> b = "abcd_33"
>>> a is b
True

但是如有其它字符，就不符合字符串驻留机制的规则了。

>>> c = 'aa%%'
>>> d = 'aa%%'
>>> c is d
False

is比较的是地址id判断是不是同一个对象，== 比较的是value

成员操作符:

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

>>> 'a' in 'abcdef'
True
>>> 'b' in 'atyu'
False
>>> 'c' not in 'cd'
False
>>> 'd' not in 'qwer'
True

字符串常用方法汇总:

>>> a
'条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。'
>>> len(a) # 长度
61
>>> a.startswith("条件") # 是否以指定字符串开头
True
>>> a.endswith("变量") # 是否以指定字符结尾
False
>>> a.find("三") # 第一次出现指定字符的位置
9
>>> a.rfind("量") # 最后一次出现指定字符的位置
59
>>> a.count("值") # 此字符一共出现了几次
3
>>> a
'条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。'
>>> a.isalnum() # 是否是全是字符或者全是数字
False
>>> 

去除首位信息:

我们可以通过strip()去除字符串收尾指定信息，通过Istrip()去除字符串左边的指定信息，rstrip是去除字符串右边的指定信息。
只去除收尾，不管中间。

>>> "*G*S*H*".strip("*")
'G*S*H'
>>> "*G*S*H*".lstrip("*")
'G*S*H*'
>>> "*G*S*H*".rstrip("*")
'*G*S*H'
>>> "   G*S*H   ".strip()
'G*S*H'
>>> 

大小写转换:

>>> a = "i love kyutech,love my FAMILY"
>>> a
'i love kyutech,love my FAMILY'
>>> a.capitalize() # 使首字母大写
'I love kyutech,love my family'
>>> a.title() # 里面每个单词的首字母大写
'I Love Kyutech,Love My Family'
>>> a.upper() # 全部大写
'I LOVE KYUTECH,LOVE MY FAMILY'
>>> a.lower() # 全部小写
'i love kyutech,love my family'
>>> a 
'i love kyutech,love my FAMILY'
>>> a.swapcase() # 大写变小写，小写变大写
'I LOVE KYUTECH,LOVE MY family'
>>> 

格式排版

>>> a = 'GSH'
>>> a.center(10,"*")
'***GSH****'
>>> a.center(10)
'   GSH    '
>>> a.ljust(10,"x")
'GSHxxxxxxx'
>>> 
>>> a.rjust(10,'x')
'xxxxxxxGSH'

其他方法:

>>> "sxt100".isalnum() # 是否全是字母和数字
True
>>> "sxt尚学堂".isalpha() # 是不是全是由字母组成(包含汉字)
True
>>> "123.6".isdigit() # 是不是全是数字
False
>>> " ".isspace() # 是不是个空格
True
>>> 'A'.isupper() # 是不是全是大写
True
>>> 'aB'.isupper()
False
>>> "abc".islower() # 是不是全是小写
True
>>> 

字符串的格式化:

format()基本用法
str.format()基本用法是通过{}和:来代替以前的%。
format函数可以接受不限个参数，位置可以不按顺序。

>>> a = "名字是:{0},年龄是:{1}"
>>> a.format("GSH",20)
'名字是:GSH,年龄是:20'
>>> b = "名字是:{0},年龄是{1}。{0}是个好小伙" # {0}还可以反复的引用
>>> b.format("XY",23)
'名字是:XY,年龄是23。XY是个好小伙'
>>> c = "名字是:{name},年龄:{age}"
>>> c.format(age = 99,name = "LH") # 这样不用关注顺序了
'名字是:LH,年龄:99'
>>> 

这样我们可以映射参数值，实现对字符串的格式化，非常方便。

填充和对齐:

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

>>> "{:*>8}".format("245")
'*****245'
>>> "我是{0},我喜欢数字{1:*<8}".format("李四","888") # 这里的8是总共8位 不够的话用*号填充
'我是李四,我喜欢数字888*****'
>>> "我是{0},我喜欢数字{1:*^8}".format("李四","888")
'我是李四,我喜欢数字**888***'