链式赋值
链式赋值用于同一个对象赋值给多个变量。
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,2,3,4
- 浮点型 小数 3.14
- 布尔型 真假 True False
- 字符串型 由字符串组成的序列 “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()
的方法实现类型的转换:
- 浮点数类型直接舍去小数部分。 如: int(9.9) 结果是: 9
- 布尔值True转为1 False转为0。如: int(True)结果是1。
- 字符串符合整数格式(浮点数格式不行) 则直接转为对应整数 否则将会报错
>>> 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
总结:
- or只要有一个True就是True 。and必须同时为True最后结果才能是True。
- or运算符中,如果a为false 则返回的是b的值,我感觉像是电路图里的并联。
>>> a = True
>>> b = False
>>> a or 30
True
>>> b or 30
30
- 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***'