最基本内置数据类型

最基本内置数据类型

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

1. 整数
2. 浮点数
3. 布尔型
4. 字符串型

数字

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()实现类型转换：

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

自动转型：
整数和浮点数混合运算时，表达式结果自动转型成浮点数

整数可以有多大：
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形式的科学计数法表示
这些数字在内存中也是按照科学计数法存储

类型转换和四舍五入

1. 类似于int()，我们也可以使用float()将其他类型转化成浮点数
2. 整数和浮点数混合运算时，表达式结果自动转型成浮点数
3. 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

注：

1. 符号之间不能加空格
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. 可以使用+将两个字符串拼接起来
   （1）如果+两边都是字符串，则拼接
   （2）如果+两边都是数字，则加法运算
   （3）如果+两边类型不同，则抛出异常
2. 可以将多个字符串直接放在一起实现拼接
   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*******'

其他方法

1. isalnum() 是否为字母或数字
2. isalpha() 检测字符串是否只由字母组成（含汉字）
3. isdigit() 检测字符串是否只由数字组成
4. isspace() 检测是否为空白符
5. isupper() 是否为大写字母
6. 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	逻辑运算符

实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织：

1. 乘除优先加减
2. 位运算和算术运算>比较运算符>赋值运算符>逻辑运算符