python 1 4 python14//3

文章目录

• 赋值

• 链式赋值
• 系列解包赋值
• 常量

• 最基本内置数据类型介绍

• 数字
• 整数
• 浮点数
• 类型转换和四舍五入
• 增强型赋值运算符
• 时间的表示
• 操作 定义多点坐标-绘出折线-并计算起始点和终点距离
• 布尔值
• 比较运算符
• 逻辑运算符
• 同一运算符

• 整数缓存问题

• 字符串

• 字符串基本特点
• 字符串的编码
• 引号创建字符串
• 空字符串和len()函数
• 转义字符
• 字符串拼接
• 字符串复制
• 不换行打印
• 从控制台上读取字符串
• str()实现数字转型字符串
• 使用【】提取字符
• replace()实现字符串替换
• 字符串切片slice操作
• split()分割和join()合并
• 字符串驻留机制和字符串比较
• 字符串比较和同一性
• 成员操作符
• 字符串常用方法汇总

• 常用查找方法
• 去除首位信息
• 大小写转换
• 格式排版
• 其他方法

• 字符串的格式化

• format()基本用法
• 填充与对齐
• 数字格式化

• 可变字符串

赋值

链式赋值

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

系列解包赋值

a,b,c=4,5,6 相当于a=4,b=5,c=6
实现变量互换

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

常量

python不支持常量

>>> MAX_SPEED=120
>>> print(MAX_SPEED)
120
>>> MAX_SPEED=140#实际可以改，逻辑不修改
>>> print(MAX_SPEED)
140

最基本内置数据类型介绍

1. 整型，即整数
2. 浮点型，小数
3. 布尔型，True ,False
4. 字符串型,“abc”,“你好”

数字

python支持整数和小数
运算符：+，-，*

/	浮点数除法
//	取整 7//2=3
%	取余 7%4=3
**	幂 2**3=8

>>> a=7/2
>>> a
3.5
>>> a=7//2
>>> a
3
>>> a=7%2
>>> a
1
>>> a=2**3
>>> a
8

注意：0不能做除数
使用divmod()函数同时得到商和除数

>>> divmod(9,5)
(1, 4)

整数

除了十进制，还有：
0b或0B,二进制 0 1
0o 0O,八进制 01234567
0X,0x，十六进制，0123456789abcdef

>>> 0b101
5
>>> 0o10
8
>>> 0o9
SyntaxError: invalid token
>>> 0xf
15
>>> 0xff
255

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

1. 浮点数直接舍去小数部分
2. 布尔值True转为1，False转为0
3. 字符串符合整数格式（浮点数格式不行）则直接转为整数，否则不行

>>> int(3.234)
3
>>> int(True)
1
>>> int(False)
0
>>> int("3242ser")
Traceback (most recent call last):
  File "<pyshell#30>", line 1, in <module>
    int("3242ser")
ValueError: invalid literal for int() with base 10: '3242ser'
>>> int("2434")
2434

自动转型：
整数和浮点数运算，结果是浮点数
整数可以有多大：
python3中int可以存储任意大小的整数，long被取消。适合科学运算。

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

浮点数

float
科学技术法
3.14,314E-2,e或E

类型转换和四舍五入

1. float()
2. 整数和浮点数混合运算时，表达式结果自动转型成浮点数
3. round(value)四舍五入，但不改变原值，而是产生新的值。

>>> float(3)
3.0
>>> 314E-2
3.14
>>> float("3.14")
3.14
>>> b=3+3.4
>>> b
6.4
>>> round(3.65)
4

增强型赋值运算符

a=a+1 等价于a+=1
其他运算符号以此类推
中间不能加空格

>>> a=12
>>> a+=1
>>> a
13

时间的表示

时间也是数字，以毫秒为单位计时，从1970年1月1日00:00：00开始。
python中可以通过time.time()获得当前时刻，整数部分是毫秒，小数部分是微秒

>>> import time
>>> time.time()
1584168039.9242876
>>> b=int(time.time())
>>> b
1584168132
>>> totalminute=b/60
>>> totalminute
26402802.2
>>> totalminute=b//60
>>> totalhours=totalminute//60
>>> totalhours
440046
>>>  totalDays=totalhours//24
 
SyntaxError: unexpected indent
>>> totalDays=totalhours//24
>>> totalDays
18335
>>> totalYears=totalDays//365
>>> totalYears
50

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

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）

布尔值

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

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

比较运算符

==	是否相等
！=	不等于
<	小于
>	大于
<=	小于等于
>=	大于等于

是真命题就是True,不是就是False

逻辑运算符

很常用

运算符	格式与说明
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

同一运算符

is：判断是不是引用一个对象
is not：是否不是一个对象
is与==区别：
is比较对象的id，而= =是比较对象的值

>>> a=1000
>>> b=1000
>>> a==b
True
>>> a is b
False
>>> id(a)
36192896
>>> id(b)
36192880

整数缓存问题

python只是对比较小的整数对象进行缓存，范围为【-5,256），在这个范围的对象会进行缓存。

>>> a=10
>>> b=10
>>> a is b
True

但是如果保存为文件执行或者在Pycharm执行，【-5，任意正整数）的范围的对象都会缓存。

is比==运算效率高，在变量和None进行比较时，用is。

字符串

字符串基本特点

字符串不是数字，更关注逻辑思维，而不是数学能力。
字符串本质是字符序列，定义好后是不可变的，只能再建一个新的。
Python不支持单字符类型，单字符就是长度是1的字符串。

字符串的编码

用Unicode，可以表示任何书面语言，默认16位。
使用内置函数ord()可以把字符串转换成对应的Unicode码。
使用内置函数chr()可以把十进制数字转换成对应的字符。

>>> ord('A')
65
>>> ord('黄')
40644
>>> chr('66')
Traceback (most recent call last):
  File "<pyshell#82>", line 1, in <module>
    chr('66')
TypeError: an integer is required (got type str)
>>> chr(66)
'B'

引号创建字符串

单引号或双引号
但如果字符串里有单引号，就应该用双引号包着，例如a=“I’m a teacher”
如果字符串里有双引号，就应该用单引号包着。
多行字符串用三个单引号或三个双引号包起来。

>>> resume='''name="hj"
company='xx' age=24
love=hjh'''
>>> print(resume)
name="hj"
company='xx' age=24
love=hjh

空字符串和len()函数

len()表示字符串长度
空字符串长度为0

>>> c=''
>>> c
''
>>> len(c)
0
>>> len('uhugen你好')
8

转义字符

\+特殊字符
\t是制表符

>>> a='i\nlove\nyou' #\n表示换行符
>>> print(a)
i
love
you
>>> b='i\'m a teacher'     #\'表示单引号
>>> print(b)
i'm a teacher
>>> print('njhihhhj\
chugibj')#\是续行符
njhihhhjchugibj

字符串拼接

+或空格相连

>>> 'ad'+'sd'
'adsd'
>>> '3'+'3'
'33'
>>> 3+3
6
>>> 'ad' 'sd'
'adsd'

字符串复制

>>> a='hj'*30
>>> a
'hjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhj'

不换行打印

end=‘任意字符串’

print('sd',end='$')
print("df",end="\t")
print("dss")

======================= RESTART: F:/python.exec/mypy06.py ======================
sd$df	dss

从控制台上读取字符串

input()

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

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

>>> str("5.20")
'5.20'
>>> str("314e-2")
'314e-2'
>>> str(314e-2)
'3.14'
>>> str(True)
'True'

使用【】提取字符

字符串就是字符序列
索引也叫偏移量
正向搜索：最左侧第一个字符，偏移量是0，直到len(str)-1
反向搜索：最右侧第一个字符，偏移量是-1

>>> a="fbjsdbfjeb"
>>> a[0]
'f'
>>> a[20]  #超过范围了
Traceback (most recent call last):
  File "<pyshell#119>", line 1, in <module>
    a[20]
IndexError: string index out of range
>>> a[-1]
'b'
>>> a[-2]
'e'

replace()实现字符串替换

字符串定义好是不可变的，如果想修改

>>> a="fbjsdbfjeb"
>>> a.replace("f","0")  #把f换成0
'0bjsdb0jeb'

实际上创建了新的字符串对象，而不是改了以前的

字符串切片slice操作

即截取子字符串
[起始偏移量start：终止偏移量end：步长step]

>>> a = "abcdefghijklmn"
>>> a[2]
'c'
>>> a[1:5]#起始偏移量到终止偏移量，包头不包尾
'bcde'
>>> a[1:5:2]
'bd'

[:]是取所有的，默认步长为1

>>> a[:]
'abcdefghijklmn'
>>> a[2:]#从2开始直到最后
'cdefghijklmn'
>>> a[:2]
'ab'

也可以反向搜索，也是包头不包尾

>>> a[-3:]
'lmn'
>>> a[:-3]
'abcdefghijk'
>>> a[::-1]#反向排
'nmlkjihgfedcba'
>>> a[2:400]#超过范围也不会报错
'cdefghijklmn'

>>> "to be or not to be"[::-1]
'eb ot ton ro eb ot'
>>> "sxtsxtsxtsxt"[::3]#输出所有s
'ssss

split()分割和join()合并

把字符串分割成多个字符串
默认按换行符、空格符、制表符分割

>>> a="to be or not to be"
>>> a.split()
['to', 'be', 'or', 'not', 'to', 'be']
>>> a.split("to")
['', ' be or not ', ' be']

join()是连接起来

>>> "abc"+"cde"
'abccde'
>>> a=['sxt','sxt100','sxt200']
>>> '*'.join(a)
'sxt*sxt100*sxt200'
>>> ''.join(a)
'sxtsxt100sxt200'

推荐用join()，因为不会生成新对象。+会生成新对象。

测试+拼接符和join()不同的效率

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))

>>> 
======================= RESTART: F:/python.exec/mypy07.py ======================
运算时间：1.2640724182128906
>>> 
======================= RESTART: F:/python.exec/mypy07.py ======================
运算时间：1.2120695114135742
运算时间：0.42902445793151855

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

字符串驻留：仅保存一份相同且不可变字符串的方法，但仅包含下划线、数字和字母。

>>> a = "hkj"
>>> b = "hkj"
>>> a is b
True
>>> c = "as_d"
>>> d = "as_d"
>>> c is d
True
>>> id(c)
36256704
>>> id(d)
36256704
>>> e = "df@12"
>>> f = "df@12"
>>> e is f
False
>>> id(a)
36319456
>>> id(b)
36319456
>>> id(e)
36319616
>>> id(f)
36319552

字符串比较和同一性

直接使用==和！=对字符串进行比较，是否含有相同的字符。
is 和not is比较的是对象的id。

成员操作符

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

>>> a = "asdfdsf"
>>> "d" in a
True
>>> "sdf" not in a
False

字符串常用方法汇总

常用查找方法

>>> a='你好，我是crammerhj'
>>> len(a)
14
>>> a.startswith('你好') #是否以指定字符串开始
True
>>> a.endswith('hj')#是否以指定字符串结尾
True
>>> a.find('r')#正向搜索
6
>>> a.rfind('r')  #反向搜索
11
>>> a.count('r')#指定字符串出现了几次
2
>>> a.isalnum()   #是否全是字母和数字
False
>>> 'vhgjh123'.isalnum()
True

去除首位信息

>>> "  sxt  ".strip()#默认去除首位空格
'sxt'
>>> " s x t ".strip()#注意是去除首位，不包括中间
's x t'
>>> "*s*x*t*".strip("*")
's*x*t'
>>> "*s*x*t**".strip("*")
's*x*t'
>>> "*s*x*t**".rstrip("*")#去除右边尾部*，lstrip（）是去除左边首部字符
'*s*x*t'

大小写转换

>>> a = "hello,world, I am hj"
>>> a.capitalize()
'Hello,world, i am hj'
>>> a.title()
'Hello,World, I Am Hj'
>>> a.upper()
'HELLO,WORLD, I AM HJ'
>>> a.lower()
'hello,world, i am hj'
>>> a.swapcase()
'HELLO,WORLD, i AM HJ'

格式排版

center(),ljust(),rjust()

>>> a = "sxt"
>>> a.center(10,"*")#10个字符
'***sxt****'
>>> a.center(10)#默认用空格
'   sxt    '
>>> a.ljust(10,"*")#左对齐
'sxt*******'

其他方法

>>> "sxt100".isalnum()#是否都是字符串
True
>>> "sxt你好".isalpha()#是否都是字母，汉字也算
True
>>> "23.2".isdigit()#是否都是数字
False
>>> "232".isdigit()
True
>>> "aA".isupper()#是否都是大写字母，islower()是小写字母
False
>>> "AA".isupper()
True
>>> "\t\n".isspace()#是否都是空白
True

字符串的格式化

format()基本用法

>>> a = "名字是：{0},年龄是：{1}"
>>> a.format("hj",24)
'名字是：hj,年龄是：24'
>>> a = "名字是：{0},年龄是：{1},{0}是一个好姑娘"#0处是同一个字符串
>>> a.format("hj",24)
'名字是：hj,年龄是：24,hj是一个好姑娘'
>>> c = "名字是{name}，年龄是{age}"
>>> c.format(age=24,name='hj')#可以不在乎顺序
'名字是hj，年龄是24'

填充与对齐

：后面表示填充的字符
^<>分别表示居中左对齐右对齐

>>> "我是{0}，我喜欢数字{1:*^8}".format("hj",666)    #8表示字符串长度
'我是hj，我喜欢数字**666***'

数字格式化

小数用f，整数用d进行格式化

>>> a = "我是{0}，我的存款有{1:.2f}"  #:.2f表示保留两位小数
>>> a.format("hj",358576.23442)
'我是hj，我的存款有358576.23'

>>> "{:0>10d}".format(3)
'0000000003'

可变字符串

io.StringIO

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