Python基础-数据类型

Python基础-数据类型

Python中有6中标准的数据类型

• Number(数字)
• String(字符串)
• List(列表)
• Turple(元组)
• Set(集合)
• Dictionary(字典)

不可变的数据(3个)： Number、String、Turple

可变的数据(3个)：List、Set、Dictionary

数字类型

数字类型的分类

在Python中支持int、float、bool、complex(复数)。

数字类型的运算规则

数学运算中的加、减、乘、除、取模、乘方等

# 加法
>>> 3+2
5
# 减法
>>> 3-2
1
# 乘法
>>> 3*2
6
# 除法
>>> 3/2
1.5
# 取整除法
>>> 3//2
1
# 乘方
>>> 3**2
9
# 取模
>>> 12 % 7
5

注意 Python数值的除法包含两个运算符： / 返回一个浮点数， // 返回是一个整数

字符串类型

字符串的表示

Python中字符串的形式有多种， 可以使用单引号('...')，双引号("...")，同时可以使用反斜杠\来转义特殊字符。

>>> 'hello'
'hello'
>>> "hello"
'hello'
>>> 'doesn\'t'
"doesn't"

字符串的拼接和复制

加号+是字符串的连接符，星号*表示复制当前字符串，与之结合的数字表示复制的次数。

>>> 'hello' + ' world' + '!'
'hello world!'
>>> 'hello' * 2
'hellohello'

字符串的切片

字符串是可以被索引下标访问的，第一个字符索引是0，单个字符并没有的类型， 只是长度为一的字符串。

字符串截取的语法格式：

变量[头下标:尾下标]

注意： 索引值是以0为开始值， -1为从末尾开始的位置

>>> word = 'Python'
>>> word[0]
'P'
>>> word[5]
'n'
>>> word[-1]
'n'
>>> word[-5]
'y'
>>> word[-6]
'P'

字符串索引可以得到单个字符， 而字符串切片可以得到子字符串。

>>> word = 'Python'
>>> word[0:2]
'Py'
>>> word[2:5]
'tho'

切片索引有默认值，省略开始索引时， 默认为0，省略结束索引时默认到字符串的结束。

>>> word = 'Python'
>>> word[:2]
'Py'
>>> word[4:]
'on'
>>> word[-2:]
'on'

可以这么理解切片：将索引视为指向字符之间的，第一个字符的左侧标为0，最后一个字符的右侧标为n，n是字符串的长度。例如

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

对于非负索引的切片，如果索引不越界， 那么切片的长度就是起止索引之差， 如word[1:3]的长度为2。

试图使用过大索引会产生一个错误：

>>> word = 'Python'
>>> word[32]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

但是切片中索引越界，会被自动处理

>>> word = 'Python'
>>> word[4:42]
'on'
>>> word[:42]
'Python'

Python中的字符串是不能被修改的，它们是immutable的。因此，向字符串索引的某个位置赋值会产生一个错误：

>>> word = 'Python'
>>> word[0] = 'J'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

总结：

• 反斜杠\用来表示转义， 可以使用r让反斜杠不转义
• 字符串可以用+连接在一起，用*运算符重复
• Python字符串中有两种索引方式：一种从左往右从0开始，一种是从右往左从-1开始
• Python中的字符串不能被改变

列表类型

列表可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型。

列表的创建

创建一个列表， 只要逗号分隔不同的数据项使用方括号括起来即可。

>>> squares = [1, 4, 9, 16]
>>> squares
[1, 4, 9, 16]

列表的操作

索引、切片、迭代、长度、运算(加、乘)*、检查成员

和字符串一样， 列表也支持索引和切片

>>> squares[0]
1
>>> squares[-1]
16
>>> squares[-3:]
[4, 9, 16]

所有切片操作都返回一个包含所请求元素的新列表。这意味着以下切片操作都会返回列表的一个浅拷贝：

>>>squares[:]
[1, 4, 9, 16]

列表同样支持拼接操作：

>>> squares + [25, 36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

与immutable的字符串不同， 列表是一个mutable类型， 就是说，它自己的内容可以改变：

>>> cubes = [1, 8, 27, 65, 125]
>>> cubes[3] = 64
>>> cubes
[1, 8, 27, 64, 125]

给切片赋值也是可以的，甚至可以改变列表大小， 或者把列表整个清空：

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

内置函数len()可以作用到列表上，计算列表的长度

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

列表的+和 *的操作符和字符串相似。+用于组合列表， * 用于重复列表。

>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> ['hi'] * 4
['hi', 'hi', 'hi', 'hi']

列表检查成员的关键词in，not in

>>> # 元素存在于列表中
>>> 3 in [1, 2, 3]
True
>>> # 元素不存在于列表中
>>> 1 not in [1, 2, 3]
False

列表的迭代操作for x in y

>>> for x in [1, 2, 3]:
...     print(x)
...
1
2
3

元组类型

Python的元组与列表类似， 不同之处在于元组的元素不能被修改。

元组使用小括号， 列表使用方括号。

元组的创建

元组的创建很简单， 只需要在括号中添加元素，并使用逗号隔开即可

>>> t = 12345, 54321, 'hello!'
>>> t
(12345, 54321, 'hello!')
>>> t1 = ('java', 'php', 'python')
>>> t1
('java', 'php', 'python')
>>> # 创建空元组
>>> t2 = ()
>>> t2
()
>>> # 类型判断
>>> type(t2)
<class 'tuple'>

注意：元组中只包含一个元素时， 需要在元素后添加逗号， 否则括号会被当做运算符使用

>>> t3 = (50)
>>> type(t3)
<class 'int'>

>>> t4 = (50,)
>>> type(t4)
<class 'tuple'>

元组的操作

索引、切片、迭代、长度、运算(加、乘)*、检查成员

元组与字符串类似， 下标索引从0开始， 可以截取、组合等

>>> t = 12345, 54321, 'hello'
>>> t[0]
12345
>>> t[-1]
'hello'

元组是immutable类型， 对元组赋值操作，会产生错误

>>> t = 12345, 54321, 'hello'
>>> t[0] = 'world'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

元组和列表类似， 是可以切片和截取的

>>> a = (1, 2, 3, 4, 5, 6)
>>> a[2:]
(3, 4, 5, 6)
>>> a[:3]
(1, 2, 3)

内置函数len()可以作用在元组上， 计算元组元素的个数

>>> a = (1, 2, 3, 4, 5, 6)
>>> len(a)
6

元组的+和*和字符串类型， +用于组合元组，*用于重复列表

>>> (1,2,3)+(4, 5, 6,)
(1, 2, 3, 4, 5, 6)
>>> (1, 2, 3) * 3
(1, 2, 3, 1, 2, 3, 1, 2, 3)

元组检查成员的关键词in，not in

>>> 1 in (1,2,3,)
True
>>> 1 not in (1, 2, 3,)
False

元组的迭代

>>> for x in (1, 2, 3,):
...     print(x)
...
1
2
3

集合类型

集合是一个无序的不重复元素序列。

可以用花括号{}或set()函数来创建集合。

注意：要创建一个空集合，只能使用set()而不能使用{}，因为花括号{}是创建一个空字典

集合创建

创建格式：

param = {value1, value2, ...}
或
set(value)

>>> # 集合是无序得不重复的
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> basket
{'orange', 'pear', 'banana', 'apple'}
>>> # set函数创建集合
>>> a = set('abracadabra')
>>> a
{'a', 'c', 'r', 'd', 'b'}
>>> # 集合推导式创建
>>> b = {x for x in 'abracadabra' if x not in 'abc'}
>>> b
{'d', 'r'}

集合操作

添加元素、移除元素、计算集合元素个数、清空集合、检查集合元素成员

添加元素的格式如下：

s.add(x)

添加集合元素即将元素添加到集合中， 如果元素已存在， 则不进行任何操作。示例如下：

>>> a = set('abracadabra')
>>> a
{'a', 'c', 'r', 'd', 'b'}
>>> # 添加一个不存在的集合元素
>>> a.add('e')
>>> a
{'a', 'e', 'c', 'r', 'd', 'b'}
>>> # 添加一个已存在的集合元素
>>> a.add('a')
>>> a
{'a', 'e', 'c', 'r', 'd', 'b'}

还有一个方法，也可以添加元素，且参数可以是列表、元组、字典等， 语法如下：

s.update(x)

x可以有多个， 用逗号,隔开。

>>> numbers = {1, 2, 3, 4 }
>>> numbers
{1, 2, 3, 4}
>>> type(numbers)
<class 'set'>
>>> numbers.update({'a', 'b'})
>>> numbers
{'a', 1, 2, 3, 4, 'b'}
>>> numbers.update(('apple', 'banana',), [6, 7, 8])
>>> numbers
{1, 2, 3, 4, 6, 7, 8, 'b', 'banana', 'a', 'apple'}

移除元素

语法格式如下：

s.remove(x)

将元素x从集合中移除， 如果元素不存在， 则会发生错误。

>>> numbers = {1, 2, 3, 4, 6, 7, 8, 'b', 'banana', 'a', 'apple'}
>>> numbers
{1, 2, 3, 4, 6, 7, 8, 'b', 'banana', 'a', 'apple'}
>>> numbers.remove(1)
>>> numbers
{2, 3, 4, 6, 7, 8, 'b', 'banana', 'a', 'apple'}
>>> numbers.remove('haha')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'haha'

此外还有一个方法也是可以移除集合中的元素， 且如果集合元素不存，不会发送错误， 格式如下：

s.discard(x)

>>> numbers = {2, 3, 4, 6, 7, 8, 'b', 'banana', 'a', 'apple'}
>>> numbers
{2, 3, 4, 6, 7, 8, 'b', 'banana', 'a', 'apple'}
>>> numbers.discard('haha')
>>> numbers
{2, 3, 4, 6, 7, 8, 'b', 'banana', 'a', 'apple'}

也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop()

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
>>> x = thisset.pop()
>>> print(x)
Taobao
>>> thisset
{'Runoob', 'Facebook', 'Google'}
>>> thisset.pop()
'Runoob'

计算集合的元素格式

语法格式如下：

len(s)

>>> a = {1, 2, 3, 4}
>>> len(a)
4

清空集合

语法格式如下：

s.clear()

>>> a = {1, 2, 3, 4}
>>> a.clear()
>>> a
set()

检查集合成员是否存在

语法格式如下

x in s

x not in s

判断元素下是否存在集合中， 存在返回True， 不存在返回False。示例如下：

>>> a = {1, 2, 3, 4}
>>> 1 in a
True
>>> 1 not in a
False

字典类型

字典是以关键字为索引， 关键字可以是任意不可变类型，通常是字符串或是数字。如果一个元组中只包含字符串、数字或元组， 那么这个元组也可以用作关键字， 但如果元组直接或间接地包含了可变对象，那么它就不能作为关键字。列表不能作为关键字， 因为列表可以通过索引、切片或者append()和extend()之类地方法来改变。

理解字典地最好方式，就是将它看做是一个键值对地集合， 键必须是唯一地(在一个字典中)。字典的每个键值key => value对用冒号:分隔， 每个键值对之间用逗号,分割， 整个字典包括在花括号{}中， 格式如下：

d = {key1 : value1, key2 : value2}

字典的创建

创建一个字典， 只要用逗号分隔每个键值对， 每个键值之间用冒号分隔， 使用花括号括起来即可

>>> tel = {'jack': 4098, 'sape':4139}
>>> a = {}
>>> a
{}
>>> # 字典推导式创建字典
>>> {x: x**2 for x in (2, 4, 6)}
>>> {2: 4, 4: 16, 6: 36}
>>> # 当关键字是简单字符串时，有时可以直接通过关键字参数来指定键值对
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}

字典的操作

访问、修改、删除、检查成员、迭代

访问字典，即把相应的键放入到方括号中，如下

>>> tel = {'jack': 4098, 'sape':4139}
>>> tel['jack']
4098

若访问字典中不存在的键， 则会产生一个错误：

>>> tel['lili']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'lili'

向字典中添加新内容的方法是增加新的键值对， 或者修改或删除已有的键值对，示例如下

>>> tel = {'jack': 4098, 'sape':4139}
>>> tel
{'jack': 4098, 'sape': 4139}
>>> tel['jack'] = 4099
>>> tel
{'jack': 4099, 'sape': 4139}
>>> tel['lucy'] = 4210
>>> tel
{'jack': 4099, 'sape': 4139, 'lucy': 4210}

能删单一元素的字典也能清空字典，清空只需一项操作。显式删除一个字典用del命令， 示例如下：

>>> # 删除单一元素
>>> del tel['jack']
>>> tel
{'sape': 4139, 'lucy': 4210}
>>> # 删除字典
>>> del tel
>>> # 清空字典
>>> dic = {'jack': 4039, 'sape': 4139}
>>> dic.clear()
>>> dic
{}

检查成员是否存在的关键字in和not in

>>> tel = {'jack': 4039, 'sape':4139}
>>> 'jack' in tel
True
>>> 'jack' not in tel
False

当在字典中循环时， 用items()方法可以将关键字和对应得值同时取出

>>> tel = {'jack': 4039, 'sape':4139}
>>> for k, v in tel.items():
...     print(k, v)
...
jack 4039
sape 4139

当在序列中循环时， 用enumerate()函数可以将索引位置和其对应得值同时去除

>>> for i, v in enumerate(['tic', 'toe', 'tac']):
...     print(i, v)
...
0 tic
1 toe
2 tac