python 数据类型

注意:

• python整数没有那么多分类, 如short long等
• python浮点数也没有那么多分类, 如double

1. 整数类型

(1). 二进制

使用0b或者0B开头的数字

0b1100

(2). 八进制

使用0O或者0o开头的数字

0O12

(3). 十六进制

使用0x或者0X开头的数字

0x12

(4). 十进制

直接写数字就是十进制

123
112

(5). 数制转换函数

2. 浮点数

(1). 小数

print(4.3, 2., .2, 1.)

结果:

4.3 2.0 0.2 1.0

0可以使用.代替

(2). 浮点数

10的n次方 使用 e的n次方表示

e前e后必有数, e后为整数

print(2e4, 0.e4, 2.e-1)

结果:

20000.0 0.0 0.2

0可以使用.代替

3. 布尔类型 bool

(1). 真 True

(2). 假 False

4. 空类型 None

None

type(None)
<class 'NoneType'>

空不等于空字符串, 空组, 0, False, 空也是一种类型, 就像int是整数类型, None是空类型

具体表现在:
1. 类型不同
2. 取值不同

(1). 判空

判断变量的值是不是None类型

a = []
if not a:
    print('S')
else:
    print('F')
if a is None:
    print('S')
else:
    print('F')
b = None
if not b:
    print('S')
else:
    print('F')
if b is None:
    print('S')
else:
    print('F')

结果:

S
F
S
S

is运算符是比较变量的内存地址是否一样, 但是所有的None类型, 地址一定是一样的

a = []
if not a:
    print('S')
else:
    print('F')
if a:
    print('S')
else:
    print('F')

b = None
if not b:
    print('S')
else:
    print('F')
if a:
    print('S')
else:
    print('F')

结果:

S
F
S
F

(2). 布尔类型与Python内置类型的关系

print('对应False', bool(''), bool([]), bool(()), bool({}), bool(0), bool(0.), bool(None))
print('对应True', bool([1]), bool((0, )), bool({1}), bool({1: 2}), bool(1.))

结果:

对应False False False False False False False False
对应True True True True True True

(3). 布尔类型与自定义类型的关系

类的布尔值, 这与__len__()和__bool__两个方法有关

具体看学习Python 之 面向对象

5. 字符串

用单引号, 双引号 和 三引号引起来的文本

(1). 单引号

单引号引起来的文本为字符串, 其中对于双引号(“)的表示可以不用使用转义符, 使用了也没事, 也会转义为双引号

>>> print('双引号""')
双引号""
>>> "\'"
"'"

ord()函数用来返回单个字符的字符串的ASCII码

>>> ord('1')
49

多个元素会报错

(2). 双引号

双引号引起来的文本为字符串, 其中对于单引号(‘)的表示可以不用使用转义符, 使用了也没事, 也会转义为双引号

>>> print("单引号''")
单引号''

(3). 三引号

三引号引起来的文本为字符串, 用来表示多行字符串

• 三个单引号

>>> print('''line 1
... line 2
... line 3
... ''')
line 1)
line 2
line 3
        # 这里是空行
>>> '''line 1)
... line 2
... line 3
... '''
'line 1)\nline 2\nline 3\n'

• 三个双引号

>>> """
... ''"""
"\n''"

区别: 单引号中的双引号的表示可以不用使用, 双引号中的单引号的表示可以不用使用

(4). ROW字符串

使用R或者r运算符对字符串进行不转义表示

>>> r'这是换行符\n'
'这是换行符\\n'
>>> r"\""
'\\"'

注意: 转义符会改变 \ 会变成 \, 及会反转义

这个代码就会报错: R"\"

因为 \"被识别为双引号”了, 所以字符串右边的引号没了

类似的, 单引号也会出现问题 R'\'

(5). 字符串截取

使用 []运算符

1) 取出某个字符

对于字符串 "hello world"

① 下标为0或者正数

下标为正数表示从前向后数, 第n位的字符

"hello world"[2]

取出下标为2的字符, 即 "l"

下标从0开始

注意: 越界(下标超出字符串长度会报错)

"hello world"[16] # 错误

② 下标为负数

下标为负数表示从后向前数, 第n位的字符

"hello world"[-2]

取出下标为-2的字符, 倒着数第二个字符, 即 "l"

③ 注意

从前向后数从0开始, 从后向前数从1开始

2) 取出多个字符(切片)

使用 [start:end]的方式

start表示开始位置, end表示结束位置

对于字符串 "hello world"

① start和end都为正数

"hello world"[0:2]

取出下标为0到下标1之间的字符, 即 "he"

"hello world"[0:20]

如果end超过了字符串长度, 则取下标从start开始到字符串结尾的所有字符串, 上述例子是结果是 "hello world"

② start与end省略

start省略表示从开头取

end省略表示取到结尾

全省略表示取整个字符串

"hello world"[4:]

取出下标为4到字符串结尾的所有字符, 即 "o world"

③ start和end为负数

负数表示倒着算起, 向右取

"hello world"[-4:-2]

取出倒数第四个字符到倒数第二个字符之间的字符, 即 "or"

④ [start🔚step]

start表示开始下标, end表示结束下标的前一个下标, step表示步长

>>> a = "123456789"
>>> print(a[0:9:3])
147

(6). 字符串填充

使用字符串的format函数来填充空缺位置

1). 空位填充

>>> string = "hello {}!"; \
... string = string.format('world'); \
... print(string)
hello world!

花括号中的表示一个空位, 使用 format函数可以填充

2). 序号填充

>>> string = "hello {0} {2} {1} {3}!"; \
... string = string.format(2.3, False, 2, None); \
... print(string)
hello 2.3 2 False None!

  花括号中的用数字表示序号, 使用 format函数以此按照从小到大序号填充, 花括号中的数字必须是从0开始, 不能跳, 但是位置可以是任意的

注意: 上述例子中, False出现的位置是1, 对应到string中会填写 {1} 的位置

3). 名字填充

>>> string = "hello {a} {sss}!"; \
... string = string.format(sss = ''' he he ''', a = "123"); \
... print(string)
hello 123  he he !

花括号中的用标识符表示名字, 使用 format函数对用赋值的方式对字符串填充

>>> string = "hello {_a2} {_}!"; \
... string = string.format(_a2 = ''' he he ''', _ = "123"); \
... print(string)
hello  he he  123!

标识符也要合法

4). f或F关键字

简化format函数, 直接可以把变量放在花括号内部, python会自动填充

a = 1
b = 2
print(F"{a}-{b}")

6. 列表

1. 定义列表

用 [常量, 常量, ... ]定义列表

[1, 2, 3.5, '"hello"']

一个列表中的元素类型可以不一样

嵌套列表

[[1, 2.0, 3.0, 4.5], [True, False, None]]

2. 访问列表

列表访问类似字符串

>>> print([1, 2, 3][2])
3

按照范围

>>> print([1, 2, 3, 5, 6, "7", "8"][-2:-1])
['7']

操作可以参考字符串, 这里不详细说啦

注意, 使用 [start:end]方式访问, 结果是列表

3. 列表操作

使用加号 +可以将两个列表合并

>>> print([1, 2] + [True])
[1, 2, True]

使用乘号号 *可以让列表重复

>>> print([True, "123"] * 3)
[True, '123', True, '123', True, '123']

>>> string = [1, 2, 3] * 3; \
... string = string[-2:]; \
... print(string)
[2, 3]

使用 list函数将字符串转变为列表, int, float, bool, None不可以

字符串会拆分为一个一个的单字符字符串转为列表

>>> l = [1, 2, 3]; \
... l += list("asd"); \
... print(l)
[1, 2, 3, 'a', 's', 'd']

列表转为字符串

>>> type(str([1, 2, 3]))
<class 'str'>

字符串转列表例子

>>> list(str([1, 2, 3]))
['[', '1', ',', ' ', '2', ',', ' ', '3', ']']

>>> list(str([1,2,3]))
['[', '1', ',', ' ', '2', ',', ' ', '3', ']']

>>> string = str([1, 2, 3]); \
... string2 = list(string); \
... print("string =", string); \
... print("string2 =", string2)
string = [1, 2, 3]
string2 = ['[', '1', ',', ' ', '2', ',', ' ', '3', ']']

列表修改

>>> l = [1, 2]; \
... l[0] = '123'; \
... print(l)
['123', 2]

追加列表元素
使用 append()函数

>>> b = [1]
>>> b.append(True)

7. 元组

用 (常量, 常量, ... )定义元组, 元组的元素是不可修改的

列表用方括号, 元组用小括号

(1). 访问与操作

访问和操作与列表相似

>>> type((1, True))
<class 'tuple'>

>>> tuple(str([1, 2, 3]))
('[', '1', ',', ' ', '2', ',', ' ', '3', ']')

使用 tuple函数将字符串转变为元组, int, float, bool, None不可以

tuple('ab')                       
('a', 'b')

元组转字符串

>>> tuple((1, True) * 2)                  
(1, True, 1, True)

(2). 元组和列表的转换

列表转元组

>>> tuple([1])
(1,)

元组转列表

>>> list((1,))
[1]

  python规定括号中只有一个元素, 如 (1)表示对该元素进行括号运算, 即单一元素元组是该元素本身, 如果要想表示一个元素的元组, 必须写成 (1,)

在元素后面加一个逗号

>>> type((1,))
<class 'tuple'>

8. 序列

在python中, 字符串(str)、列表(list) 和 元组(tuple) 都是序列

操作函数

9. 集合

集合最大的特性是: 无序

(1). 定义集合

使用花括号定义集合

>>> {1, 3, 2}
{1, 2, 3}

定义空集合, 使用 set()函数

>>> type(set())
<class 'set'>

(2). 特性

1). 无序

不支持 []和 [start:end]操作

2). 不重复

>>> {1, 3, 2, 3, 3, 2}
{1, 2, 3}

(3). 操作

1). 差集

使用减号 -

>>> {1, 2, 3} - {1}
{2, 3}

2). 交集

使用 &

>>> {1, 2, 3} & {1}
{1}

3). 并集

使用 |

>>> {1, 2, 3} | {1, 4}
{1, 2, 3, 4}

10. 字典

字典由Key和Value组成, 且Key不能重复, 如果重复, 新值覆盖旧值, key的类型是不可变类型, value类型任意

(1). 定义字典

使用花括号
{key1 : value1, key2 : value2 , ... , key n : value n}

>>> type({1 : 1, 2 : 2})
<class 'dict'>

空字典

>>> type({})
<class 'dict'>

(2). 字典访问

使用 [key]方式访问字典

>>> {1 : 1, 2 : 2}[1]
1