最基本内置数据类型
每个对象都有类型,python中最基本的内置数据类型:
- 整数
- 浮点数
- 布尔型
- 字符串型
数字
Python支持整数和浮点数,我们可以对数字做如下运算:
运算符 | 说明 |
---|---|
+ | 加法 |
- | 减法 |
* | 乘法 |
/ | 浮点数除法 eg. 8/2=4.0 |
// | 整数除法 |
% | 模(取余) |
** | 幂 |
使用divmod()函数同时得到商和余数,会返回一个元组
divmod(13,3)
(4,1)
整数
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
这三种进制可以非常方便的进行“位运算”操作
使用int()实现类型转换:
- 浮点数直接舍去小数部分
- 布尔值True转为1,False转为0
- 字符串符合整数格式(浮点数格式不行)则直接转成对应整数,否则报错
自动转型:
整数和浮点数混合运算时,表达式结果自动转型成浮点数
整数可以有多大:
Python2中,int是32位,可以存储从-2147483648到2147483647的整数(约±21亿)。Long类型是64位,可以存储:-2^63 – 2^63-1之间的数值。
Python3中,int可以存储任意大小的整数,long被取消。Python3中可以做出超大数的计算,而不会造成“整数溢出”,这也是Python特别适合科学运算的特点。
整数缓存问题
Python仅仅对比较小的整数对象进行缓存(范围为[-5,256])缓存起来,而并非是所有整数对象。需要注意的是,这仅仅实在命令行中执行,而在Pycharm或者保存为文件执行,结果是不一样的,这是因为解释器做了一部分优化(范围是[-5,任意正整数])
eg.
>>> c=10
>>> d=10
>>> c is d
True
浮点数
浮点数,称为float。
浮点数用a x b^10形式的科学计数法表示
这些数字在内存中也是按照科学计数法存储
类型转换和四舍五入
- 类似于int(),我们也可以使用float()将其他类型转化成浮点数
- 整数和浮点数混合运算时,表达式结果自动转型成浮点数
- round(value)可以返回四舍五入的值
注意:不会改变原有值,会生成一个新的对象
增强型赋值运算符
运算符+、-、*、/、//、**和%和赋值符=结合可以构成“增强型赋值运算符”
运算符 | 等价 |
---|---|
+= | a+=2 => a=a+2 |
-= | a-=2 => a=a-2 |
*= | a*=2 => a=a*2 |
/= | a/=2 => a=a/2 |
//= | a//=2 => a=a//2 |
**= | a**=2 => a=a**2 |
%= | a%=2 => a=a%2 |
注:
- 符号之间不能加空格
- Python不支持自增(++)或自减(–)
时间的表示
计算机中时间的表示是从“1970年1月1日 00:00:00”开始,以毫秒(1/1000秒)进行计时。我们把1970年这个时刻称为“unix时间点”。这样,我们就把时间全部都用数字来表示了。
Python中可以通过time.time()获得当前时刻,返回的值是以秒为单位,带微秒(1/1000毫秒)京都的浮点数值。
布尔值
Python2中没有布尔值,直接食用数字0表示False,用数字1表示True。
Python3中,把True和False定义成了关键字,但它们的本质还是1和0,甚至可以和数字相加
比较运算符
所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。
运算符 | 描述 |
---|---|
== | 等于-比较对象的值是否相等 |
!= | 不等于-比较两个对象的值是否不相等 |
> | 大于-返回x是否大于y |
< | 小于-返回x是否小于y |
>= | 大于等于-返回x是否大于等于y |
<= | 大于-返回x是否小于等于y |
逻辑运算符
运算符 | 说明 |
---|---|
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 |
eg. a or 30
会发生短路现象,如果a是true,就直接把它返回,后面的就不运算
同一运算符
同一运算符用于比较两个对象的存储单元,实际比较的是对象的地址
运算符 | 说明 |
---|---|
is | is是判断两个标识符是不是引用同一个对象 |
is not | is not是判断两个标识符是不是引用不同对象 |
is 和 == 的区别:
- is用于判断两个变量引用对象是否为同一个,即比较对象的地址
- ==用于判断引用变量引用对象的值是否相等,默认调用对象的__eq__()方法
- is运算符比==效率高,在变量和None进行比较时,应该使用is
eg.
>>> a=1000
>>> b=1000
>>> a == b
True
>>> a is b
False
>>> id(a)
46764560
>>> id(b)
46765216
字符串
字符串基本特点:
- 字符串的本质是:字符序列
- Python的字符串是不可变的,我们无法对原字符串做任何修改。但可以将字符串的一部分复制到新创建的字符串,达到“看起来修改”的效果
- Python不支持单字符类型,单字符也是作为一个字符串使用的
字符串的编码:
- Python3直接支持Unicode。可以表示世界上任何书面语言的字符。Python3的字符默认就是16位Unicode编码,ASCII码是Unicode编码的子集
- 使用内置函数ord()可以把字符转换成对应的Unicode码
- 使用内置函数chr()可以把十进制数字转换成对应的字符
引号创建字符串
我们可以通过单引号或双引号创建字符串。使用两种引号的好处是可以创建本身就包含引号的字符串,而不使用转义字符。
连续三个单引号或三个双引号,可以帮助我们创建多行字符串。
空字符串和len()函数
Python允许空字符串的存在,不包含任何字符且长度为0
len()用于计算字符串含有多少字符,eg. len(d)
转义字符
我们可以使用“+特殊字符”。实现某些难以用字符表示的效果
转义字符 | 描述 |
---|---|
\(在行尾时) | 续行符 |
\ | 反斜杠符号 |
’ | 单引号 |
" | 双引号 |
\b | 退格(Backspace) |
\n | 换行 |
\t | 横向制表符 |
\r | 回车 |
eg.
>>> print('aaaaaa\
cccccddddd')
aaaaaacccccddddd
字符串拼接
- 可以使用+将两个字符串拼接起来
(1)如果+两边都是字符串,则拼接
(2)如果+两边都是数字,则加法运算
(3)如果+两边类型不同,则抛出异常 - 可以将多个字符串直接放在一起实现拼接
eg. ‘aa’‘bb’ => ‘aabb’
注:两种方法都会产生新的对象
字符串复制
使用*可以实现字符串复制
eg.
>>> a='Sxt'*3
>>> a
'SxtSxtSxt'
不换行打印
我们前面调用print时,会自动打印一个换行符,有时,我们不想换行,不想自动添加换行符。我们可以自己通过参数end=“任意字符串”,实现末尾添加任何内容
eg.
>>> print("sxt",end=' ')
>>> print("sxt",end='##')
>>> print("sxt")
sxt sxt##sxt
从控制台读取字符串
我们可以使用input()从控制台读取键盘输入的内容
eg.
>>> myname = input("请输入名字:")
请输入名字:高
>>> myname
高
str()实现数字转型字符串
str()可以帮助我们将其他数据类型转换为字符串。
当我们调用print()函数时,解释器自动调用了str()将非字符串的对象转换成了字符串。
使用[ ]提取字符
字符串的本质就是字符序列,我们可以通过在字符串后面添加[ ],在[ ]里面指定偏移量,可以提取该位置的单个字符。
- 正向搜索:最左侧第一个字符,偏移量是0,第二个偏移量是1,以此类推,知道len(str)-1
- 反向搜索:最右侧第一个字符,偏移量是-1,倒数第二个偏移量是-2,以此类推,直到-len(str)为止
eg.
>>> a="abcdefghijklmnopqrstuvwxyz"
>>> a[0]
'a'
>>> a[-1]
'z'
>>> a[-26]
'a'
replace()实现字符串替换
字符串是“不可改变”的,但是,我们却是有时候需要替换某些字符。这时,只能通过创建新的字符串来实现。
eg.
>>> a.replace("c","高")
'ab高defghijklmnopqrstuvwxyz' #新字符串
>>> a
'abcdefghijklmnopqrstuvwxyz'
>>> a = a.replace("c","高")
>>> a
'ab高defghijklmnopqrstuvwxyz'
字符串切片slice操作
切片slice操作可以让我们快速的提取子字符串。标准格式为:
[起始偏移量start : 终止偏移量end : 步长step]
典型操作(三个量为正数的情况)如下:
操作和说明 | 示例 |
---|---|
[:] 提取整个字符串 | “abcdef” [:] => “abcdef” |
[start:] 从start索引开始到结尾 | “abcdef” [2:] => “cdef” |
[:end] 从头开始直到end-1 | “abcdef” [:2] => “ab” |
[start:end] 从start到end-1 | “abcdef” [2:4] => “cd” |
[start?step] 从start提取到end-1,步长是step | “abcdef” [1:5:2] => “bd” |
其他操作(三个量为负数)的情况
说明 | 示例 |
---|---|
倒数三个 | “abcdefghijklmnopqrstuvwxyz [-3:] => “xyz” |
倒数第八个到倒数第三个(包头不包尾) | “abcdefghijklmnopqrstuvwxyz [-8:-3] => “stuvw” |
步长为负数,从右到左反向提取 | “abcdefghijklmnopqrstuvwxyz [::-1] => “zyxwvutsrqponmlkjihgfedcba” |
切片操作是,起始偏移量和终止偏移量不再[0,字符串长度-1]这个范围,也不会报错。起始偏移量小雨0则会被当作0,终止偏移量大于"长度-1"会被当成-1
eg.
>>> "abcdefg"[3:50]
'defg'
split()分割和join()合并
split()可以基于指定分隔符将字符串分隔成多个子字符串(存储到列表中)。如果不指定分隔符,则默认使用空白字符(换行符/空格/制表符)
eg.
>>> a = "to be or not to be"
>>> a.split()
['to','be','or','not','to','be']
>>>a.split('be')
['to','or not to','']
join()的作用和split()作用刚好相反,用于将一些列子字符串连接起来
eg.
>>> a = ['sxt','sxt100','sxt200']
>>>'*'.join(a)
'sxt*sxt100*sxt200'
拼接字符串要点
使用字符串拼接符+,会生成新的字符串对象,因此不推荐使用+来拼接字符串。推荐使用join函数,因为join函数在拼接字符串之前会计算所有字符串的长度,然后逐一拷贝,仅新建一次对象
字符串驻留机制和字符串比较
字符串驻留
仅保存一份相同且不可变字符串的方法,不同的值被存放在字符串驻留池中。Python支持字符串驻留机制,对于符合标识符规则的字符串(仅包含下划线、字母和数字)会启用字符串驻留机制
eg.
>>> a = "abc_33" #在内存中会创建一个"abc_33"对象
>>> b = "abc_33" #不会新创建一个对象,而是直接引用上面的对象
>>> a is b
True
>>> c = "dd#"
>>> d = "dd#"
>>> c is d
False
>>> c == d
True
字符串比较和同一性
我们可以直接使用==,!=对字符串进行比较,是否含有相同的字符
我们使用is / not is 判断两个对象是否是同一个对象。比较的是对象的地址
成员操作符
in / not in 关键字,判断某个字符(子字符串)是否存在于字符串中
eg.
>>> a = "abcdefg"
>>> "b" in a
True
>>> "bcd" in a
True
>>> "ddd" in a
False
>>> "ddd" not in a
True
字符串常用查找方法
以一段文本作为测试:
a=’’‘我是高淇,今年18岁了,我在北京尚学堂科技上班。我的儿子交高洛希,他6岁了。我是一个编程教育的普及者,希望影响6000万学习编程的中国人。我儿子现在也开始学习编程,希望他18岁的时候可以超过我’’’
方法 | 说明 |
---|---|
len(a) => 96 | 字符串长度 |
a.startswith(“我是高淇”) => True | 以指定字符串开头 |
a.endswith(“过我”) => True | 以指定字符串结尾 |
a.find(“高”) => 2 | 第一次出现指定字符串的位置 |
a.rfind(“高”) => | 最后一次出现指定字符串的位置 |
a.count(“编程”) => 3 | 指定字符串出现了几次 |
a.isalnum() => False | 所有字符串全是字母或数字 |
去除首尾信息
我们可以通过strip()去除字符串首尾指定信息。通过lstrip()去除字符串左边指定信息,rstrip()去除字符串右边指定信息
eg.
>>> "*s*x*t*".strip("*")
's*x*t'
>>> "*s*x*t*".lstrip("*")
's*x*t*'
>>> "*s*x*t*".rstrip("*")
'*s*x*t'
>>> " sxt ".strip()
'sxt'
大小写转换
eg. 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()这三个函数用于对字符串实现排版
eg.
>>> a = "SXT"
>>> a.center(10,"*")
'***SXT****'
>>> a.center(10)
' SXT '
>>> a.ljust(10,"*")
'SXT*******'
其他方法
- isalnum() 是否为字母或数字
- isalpha() 检测字符串是否只由字母组成(含汉字)
- isdigit() 检测字符串是否只由数字组成
- isspace() 检测是否为空白符
- isupper() 是否为大写字母
- islower() 是否为小写字母
字符串的格式化
format()基本用法:
Python2.6开始,新增了一种格式化字符串的函数str.format(),它增强了字符串格式化的功能。
基本语法是通过{ }和:来代替以前的%
format()函数可以接受不限个参数,位置可以不按顺序
我们可以通过{索引}/{参数名},直接映射参数值,实现对字符串的格式化
eg.
>>> a = "名字是:{0},年龄是:{1}" # {0}和{1}相当于占位符
>>> a.format("高淇",18)
‘名字是:高淇,年龄是:18’
>>> a.format("高希希",6)
'名字是:高希希,年龄是:6'
>>> b = "名字是:{0},年龄是:{1}。{0}是个好小伙"
>>> b.format("高淇",18)
'名字是:高淇,年龄是:18。高淇是个好小伙'
>>> c= "名字是:{name},年龄是:{age}"
>>> c.format(age=19,name='高淇')
‘名字是:高淇,年龄是:19’
填充常跟对齐一起使用
^、<、>分别是剧中、左对齐、右对齐,后面带宽度
:后面带填充的字符,只能是一个字符,不指定的话默认是用空格填充
eg.
>>> "{:*>8}".format("245")
'*****245'
>>> "我是{0},我喜欢数字{1:*^8}".format("高淇","666")
'我是高淇,我喜欢数字**66***'
数字格式化
浮点数通过f,整数通过d进行需要的格式化
eg.
>>> a= "我是{0},我的存款有{1:.2f}"
>>> a.format("高淇",3888.234342)
'我是高淇,我的存款有3888.23'
其他格式:
描述 | 示例 |
---|---|
保留小数点后两位 | 3.1415926 {:.2f} => 3.14 |
带符号保留小数点后两位 | 3.1415926 {:+.2f} => 3.14 |
不计小数 | 2.71828 {:.0f} => 3 |
数字补零(填充左边,宽度为2) | 5 {:0>2d} 5 |
数字补x(填充右边,宽度为4) | 5 {:0<4d} 5xxx |
数字补x(填充右边,宽度为4) | 10 {:0<4d} 10xx |
以逗号分隔的数字形式 | 1000000 {:,} => 1,000,000 |
百分比格式 | 0.25 {:.2%} => 25.00% |
指数记法 | 1000000000 {:.2e} => 1.00E+09 |
右对齐(默认,宽度为10) | 13 {:10d} =>左边有八个空格13 |
左对齐(宽度为10) | 13 {:<10d} => 13右边有八个空格 |
中间对齐(宽度为10) | 13 {:^10d} => 13在中间 |
可变字符串
在Python中,字符串属于不可变对象,不支持原地修改,如果需要修改其中的值,只能创建新的字符串对象。但是,我们经常需要原地修改字符串,ke
以使用io.StringIO对象或array模块
eg.
>>> import io
>>> s = "hello,sxt"
>>> sio = io.StringIO(s)
>>> s
<_io.StringIO object at 0x02F46280>
>>> sio.getvalue()
'hello, sxt'
>>> sio.seek(7) #让指针移动到指定的字符 's'
7
>>> sio.write("g")
1
>>> sio.getvalue()
'hello, gxt'
基本运算符
运算符 | 说明 |
---|---|
or, and, not | 布尔或、布尔与、布尔非 |
is, is not | 同一性判断,判断是否为同一对象 |
<, <=, >, >=, !=, == | 比较值是否相等,可以连用 |
| ^ & | 按位或,按位异或,按位与 |
<<, >> | 移位 |
~ | 按位翻转 |
+,-,*,/,//,% | 加、减、乘、除、浮点除、整数除、取余 |
** | 幂运算 |
eg.
>>> a=4
>>> 3<a<10
True
>>> a=0b11001
>>> b=0b01000
>>> a
25
>>> b
8
>>> c=a|b
>>> c
25
>>> bin(c)
'0b11001'
>>> bin(a&b)
'0b1000'
>>> bin(a^b)
'0b10001'
>>> d = 3
>>> a<<2 #左移1位相当于乘以2,左移两位,相当于乘以4,比较快
12
>>> d = 8
>>> a>>1 #右移1位相当于除以2
4
eg.
[10,20,30]+[5,10,100] => [10,20,30,5,10,100]
“sxt”*3 => “sxtsxtsxt”
[10,20,30]*3 => [10,20,30,10,20,30,10,20,30]
运算符优先级
从高到低
运算符 | 描述 |
---|---|
** | 指数(最高优先级) |
~ | 按位翻转 |
* / % // | 乘、除、取余、整数除 |
+ - | 加、减 |
>> << | 右移、左移 |
& | 位’AND’ |
^ | | 位运算 |
<= < > >= | 比较运算符 |
<> == != | 等于运算符 |
= %= /= //= -= += *= **= | 赋值运算符 |
is is not | 身份运算符 |
in not in | 成员运算符 |
not or and | 逻辑运算符 |
实际使用中,记住如下简单的规则即可,复杂的表达式一定要使用小括号组织:
- 乘除优先加减
- 位运算和算术运算>比较运算符>赋值运算符>逻辑运算符