Python基础之标准数据类型

六个标准数据类型

  • 不可变数据：Number，String，Tuple（元组）
  • 可变数据：List（列表），Dictionary（字典），Set（集合）

string、list 和 tuple 都属于 sequence（序列）

序列有先后关系，元素间由序号引导，通过下标访问特定元素。

序列中元素类型可以不相同

序列类型有通用的操纵符，在介绍String类型时会介绍，list与tuple类型不再介绍。

Number

表示

支持int、float、bool、complex

  • int（整型）

    Python中的int没有取值范围限制，可正可负
    在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

    四种进制表示：十进制 二进制（0b或0B开头） 八进制（0o或0O开头） 十六进制（0x或0X开头）

  • float（浮点型）
    浮点数运算存在不确定尾数(原因是二进制转化为十进制)

    0.001100110011……(二进制) 0.100000000……(十进制)

    • 数学写法: 1.23，-9.01

    • 科学计数法表示浮点数：

      使用e或E作为幂的符号，以10为基数，格式如下：<a>e<b> 表示a*10^b

      例如4.3e-3值为0.0043

    round(x,d):对x四舍五入，d是小数截取位数

    0.1+0.2 == 0.3

    False

    round(0.1+0.2,1) == 0.3

    True

  • bool（布尔型）

    在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

    True == 1

    True

  • complex

    复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

    z.real 获得实部

    z.imag 获得虚部

String(字符串)

表示

  1. 一对单引号或双引号(仅单行)
  2. 一对三引号(可多行)

序列类型通用

序号的定义

从首位到末尾索引从 0 开始递增；从末尾到首位索引从-1开始递减。

6个操作符

操作符及应用 描述
s + t 连接两个序列s和t
s*n或 n*s 将序列s复制n次
x in s 如果x是序列s的元素，返回True，否则返回False
x not in s 如果x是序列s的元素，返回False，否则返回True
s[i] 索引，返回s中的第i个元素，i是序列的序号
s[i:j] 或 s[i:j:k] 切片，返回序列s中第i到j以k为步长的元素子序列

Python 字符串和元组不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。

a, b= 'Hello', 'Python'

a + b

'HelloPython'

a * 2

'HelloHello'

'H' in a

True

通用函数与方法

函数和方法 描述
len(s) 返回序列s的长度，即元素个数
min(s) 返回序列s的最小元素，s中元素需要可比较
max(s) 返回序列s的最大元素，s中元素需要可比较
s.index(x)或s.index(x,i,j) 返回序列s从i开始到j位置中第一次出现元素x的位置
s.count(x) 返回序列s中出现x的总次数

转义字符

Python 使用反斜杠 \ 转义特殊字符，如果不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

print('Ru\noob')

Ru
oob

print(r'Ru\noob')

Ru\noob
转义字符 描述 实例
\(在行尾时) 续行符 >>> print("line1 \ ... line2 \ ... line3")
\\ 反斜杠符号 >>> print("\\") \
\' 单引号 >>> print('\'') '
\" 双引号 >>> print("\"") "
\a 响铃 >>> print("\a")执行后电脑有响声。
\b 退格(Backspace) >>> print("Hello \b World!") Hello World!
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。 >>> print('google runoob taobao\r123456') 123456 runoob taobao
\f 换页
\yyy 八进制数，y 代表 0~7 的字符，例如：\012 代表换行。 >>> print("\110\145\154\154\157\40\127\157\162\154\144\41") Hello World!
\xyy 十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行 >>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21") Hello World!
\other 其它的字符以普通格式输出

字符串格式化

格式： <模板字符串>.format(<逗号分隔的参数>)

模板字符串中，槽内部对格式化的配置方式 {<参数符号>:<格式控制标记>}

: <填充> <对齐> <宽度> <,> <.精度> <类型>
引导符号 用于填充的单个字符 < 左对齐 >右对齐 ^居中对齐 槽设定的输出宽度 数字的千位分隔符 浮点数小数或字符串最大输出长度 整数类型b,c,d,o,x,浮点数类型,e,E,f,% 
"{0:,.2f}".format(0.2)

'0.20'

"{0:=^20}".format("PYTHON")

'=======PYTHON======='

处理函数

  1. str(x)任意类型x所对应字符串形式

  2. hex(x),oct(x) 整数x的十六进制或八进制小写形式字符串

    hex(425)结果为“0x1a9”oct(425)结果为“0o651"

  3. chr(x)x为Unicode编码，返回其对应的字符

  4. ord(x)x为字符，返回其对应的Unicode编码

处理方法

主要形式：<a>.<b>()

  1. str.lower()或str.upper() 全部字符小写/大写

  2. str.split(sep=None)返回一个列表，由str根据sep被分隔的部分组成

  3. str.count(sub)返回子串sub在str中出现的次数

  4. str.replace(old,new)返回字符串str副本，所有old子串被替换为new

  5. str.center(width[,fillchar])字符串str根据宽度width居中，fillchar可选

  6. str.strip(chars)从str中去掉在其左侧和右侧chars中列出的字符串

  7. str.join(iter)在iter变量除最后元素外每个元素后增加一个str

  8. str.format()格式化

"A,B,C".split(",")

['A', 'B', 'C']

"python".replace("n","n123.io")

'python123.io'

",".join("1234")

'1,2,3,4'

Tuple（元组）

元组（tuple）是一种序列类型，一旦创建不能修改，但它可以包含可变的对象，比如list列表。

元祖类型定义

  • 使用小括号()（也可以不使用）或tuple()创建，元素间用逗号,分隔。

    creature = "cat", "dog", "tiger", "human"
creature

    ('cat', 'dog', 'tiger', 'human')

    color = (0x001100, "blue", creature)
color

    (4352, 'blue', ('cat', 'dog', 'tiger', 'human'))

  • 构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

    tup1 = () #空元组

    tup2 = (20,) #一个元素时需要在元素后加逗号

List（列表）

列表中的元素可以是不同类型,它支持数字，字符串甚至可以包含列表（所谓嵌套）。

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x

[['a', 'b', 'c'], [1, 2, 3]]

x[0]

['a', 'b', 'c']

列表类型定义

列表使用方括号[]或list()创建，元素用逗号,分隔

列表中方括号 [] 才会真正创建一个列表，赋值仅传递引用。

b = a
b

['a', 'b', 'c']

b[0] = 8
a # a也发生了变化，说明b并非实体

[8, 'b', 'c']

列表类型操作函数和方法

函数或方法 描述
ls[i] = x 替换列表ls第i元素为x
ls[i: j: k] = lt 用列表lt替换ls切片后所对应元素子列表
del ls[i] 删除列表ls中第i元素
del ls[i: j: k] 删除列表ls中第i到第j以k为步长的元素
ls += lt 更新列表ls，将列表lt元素增加到列表ls中
ls *= n 更新列表ls，其元素重复n次

列表允许修改操作，赋值操作。因而可以改变列表的尺寸

a = [1,3,23,4,67]
a[3] = 90
a

[1, 3, 23, 90, 67]

a[1:2] = [0,2,'123']
a

[1, 0, 2, '123', 23, 90, 67]

a[1:3] = []
a

[1, '123', 23, 90, 67]

注意：

a[0] = [1,3,5]
a

[[1, 3, 5], '123', 23, 90, 67]
函数或方法 描述
ls.append(x) 在列表ls最后增加一个元素x
ls.clear() 删除列表ls中所有元素
ls.copy() 生成一个新列表，赋值ls中所有元素
ls.insert(i,x) 在列表ls的第i位置增加元素x
ls.pop(i) 将列表ls中第i位置元素取出并删除该元素
ls.remove(x) 将列表ls中出现的第一个元素x删除
ls.reverse() 将列表ls中的元素反转

Dictionary（字典）

字典是无序的对象集合。字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，是一种键(索引)和值(数据)的对应。

字典类型定义

采用大括号{}和dict()创建，键值对用冒号: 表示

键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的

dict = {}
dict['one'] = "一"
dict[2] = "二"
dict

{2: '二', 'one': '一'}

字典类型操作函数和方法

函数或方法 描述
del d[k] 删除字典d中键k对应的数据值
k in d 判断键k是否在字典d中，如果在返回True，否则False
d.keys() 返回字典d中所有的键信息
d.values() 返回字典d中所有的值信息
d.items() 返回字典d中所有的键值对信息 
dict.keys()

dict_keys(['one', 2])
函数或方法 描述
d.get(k, <default>) 键k存在，则返回相应值，不在则返回<default>值
d.pop(k, <default>) 键k存在，则取出相应值，不在则返回<default>值
d.popitem() 随机从字典d中取出一个键值对，以元组形式返回
d.clear() 删除所有的键值对
len(d) 返回字典d中元素的个数

Set（集合）

集合是一个无序不重复元素的序列，不可更改。

可以使用大括号{ }或者set()函数创建集合，但是创建一个空集合必须用set()而不是{ }，因为 { }是用来创建一个空字典。

操作符

操作符及应用 描述
`S T`
S-T 差，返回一个新集合，包括在集合S但不在T中的元素
S&T 交，返回一个新集合，包括同时在集合S和T中的元素
S^T 补，返回一个新集合，包括集合S和T中的非相同元素
S<=T或S<T 返回True/False，判断S和T的子集关系
S>=T或S>T 返回True/False，判断S和T的包含关系
`S = T`
S -= T 差，更新集合S，包括在集合S但不在T中的元素
S &= T 交，更新集合S，包括同时在集合S和T中的元素
S ^= T 补，更新集合S，包括集合S和T中的非相同元素

操作函数

操作函数或方法 描述
S.add(x) 如果x不在集合S中，将x增加到S
S.discard(x) 移除S中元素x，如果x不在集合S中，不报错
S.remove(x) 移除S中元素x，如果x不在集合S中，产生KeyError异常
S.clear() 移除S中所有元素
S.pop() 随机返回S的一个元素，更新S，若S为空产生KeyError异常
S.copy() 返回集合S的一个副本
len(S) 返回集合S的元素个数
x in S 判断S中元素x，x在集合S中，返回True，否则返回False
x not in S 判断S中元素x，x不在集合S中，返回True，否则返回False
set(x) 将其他类型变量x转变为集合类型 
a = {1,2,3,1,3,5,6}
a # 消除重复元素

{1, 2, 3, 5, 6}

a = {'abracadabra'}
a

{'abracadabra'}

a = set('abracadabra')
b = set('alacazam')
a

{'a', 'b', 'c', 'd', 'r'}

# 集合运算
a - b # a和b的差集

{'b', 'd', 'r'}

a ^ b # a和b不同时存在的元素

{'b', 'd', 'l', 'm', 'r', 'z'}

参考：
菜鸟教程 https://www.runoob.com/python/python-variable-types.html
中国大学MOOC

posted @ 2021-07-10 18:03  艾雅雅雅  阅读(231)  评论(0)    收藏  举报