三、数据类型

Python中的变量不需要声明，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在Python中，变量就是变量，它没有类型，我们所说的“类型”是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名，等号（=）运算符右边是存储在变量中的值。

1、标准数据类型

Python3中有六个标准数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Number（数字）Python数字类型分为：

• int（整型）
• float(浮点型)
• bool（布尔型）
• complex（复数）

在Python3中，只有一种整数类型int，表示为长整型，没有Python2中的Long。

像大多数语言一样，数值类型的赋值和计算都是很直观的。

内置的type()函数可以用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

此外还可以用isinstance来判断：

>>>a = 111
>>> isinstance(a, int)
True

isinstance和type的区别在于：

class A:
    pass

class B(A):
    pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True	#isinstance()会认为子类是一种父类类型。
type(B()) == A        # returns False	#type()不会认为子类是一种父类类型。

区别就是：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

注意：

在python2中是没有布尔型的，他用数字0表示False，用1表示True。

Python3中，把True和False定义成关键字了，但它们的值还是1和0，它们可以和数字相加。

当你指定一个值时，Number对象就会被创建：

var1 = 1
var2 = 10

你也可以使用del语句删除一些对象引用。

del语句的语法是：

del var1, var2, var3...		#del 后可跟一到多个对象引用

你可以通过使用del语句删除单个或多个对象。例如：

del var		#不要将关键字命名为变量，否则会有问题
del var1, var2, var3...

注意：

• Python可以同时为多个变量赋值；

• #如：
  #对称赋值
  a, b = 1, 2	
  a, b, c, d = 'love'
  print(a)
  print(b)
  print(c)
  print(d)
  >>> l
  >>> o
  >>> v
  >>> e
  #统一赋值
  a = b = c = d = 10;
  

• 一个变量可以通过赋值指向不同类型的对象；

• 数值的除法（/）总是返回一个浮点数，要获取整数使用（//）运算符；

• 在混合计算时，如果包含有（/）运算符，Python会把整数转换成为浮点数（浮点型的优先级比整型高，所以只要运算式中出现浮点型，结果就为浮点型）。

  print(1 + 2 * 4 - 2 ** 3 + 3 // 2 + 3 % 2)
  print(1 + 2 * 4 / 2 )

数值类型实例

int float complex
10 0.0(.2) 3.14j
100 15.20 45j
-786 -21.9 9.322e-36j

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

数值运算的模块 import math

函数	函数含义
pow(x, y)	x ** y运算后的值
round(x[, n])	返回浮点数x的四舍五入值，如给出n值，则表示舍入到小数点后的位数
max(x1, x2…)	返回给定参数的最大值，参数可以为序列
min(x1, x2…)	返回给定参数的最小值，参数可以为序列
ceil(x)	返回数字的上入整数，如math.ceil(4.1)返回5
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回4

随机数的函数 import random

函数	函数含义
choice(seq)	返回一个列表，元组或字符串的随机项。 seq – 可以是一个列表，元组或字符串。
choices(seq, k=1)	返回随机的k个值，返回的结果为列表(同一个元素会有多次被选中的情况)
randrange（start, stop, step）	start – 指定范围内的开始值，包含在范围内。stop – 指定范围内的结束值，不包含在范围内。step – 指定递增基数。不包含尾值
shuffle(list)	将列表的所有元素随机排序（直接修改原值，不返回值）
randint(1,100)	随机整数（必须只给两个参数）,包含尾值

import random
List = [1, 2, 3]
random.shuffle(List)
print(List)
print(random.shuffle(List))
>>> [2, 1, 3]	#直接修改原值
>>> None		#不返回值

序列 字符串 列表 元组的取值方式

截取的语法格式如下：

变量[头下标： 尾下标]

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

加号（+）是字符串的连接符，星号（*）表示复制当前字符串，紧跟的数字为复制的次数。

2、字符串

Python中的字符串用单引号(’)或双引号(")括起来，同时使用反斜杠()转义特殊字符。

字符串的截取的语法格式如下：

变量[头下标：尾下标]

索引值以0为开始值，-1为从末尾的开始位置。

加号（+）是字符串的连接符，星号（*）表示复制当前字符串，紧跟的数字为复制的次数。

实例如下：

str1 = 'lucky'
print(str1)				#输出字符串		
>>> lucky
print(str1[0: -1])		#输出第一个到倒数第二个（不包含尾字符）的所有字符
>>> luck
print(str1[-3: -1])		#输出倒数第三个到倒数第二个字符
>>> ck
print(str1[0])			#输出字符串的第一个字符
>>> l
print(str1[2: 5])		#输出第三个到第五个字符
>>> cky
print(str1[2:])			#输出从第三个开始的后的所有字符
>>> cky
print(str1[:])			#输出所有
>>> lucky
print(str1[:3])			#截取到3为止
>>> luc
print(str1 * 2)			#输出字符串两次
>>> luckylucky
print(str1 + 'TEST')	#连接字符串
>>> luckyTEST
print(str1[-1:1:-1])	#范围查询，步长默认是1，如果步长为正，从左往右查询，如果步长为负，从右往左查询
>>> ykc
print(str1[-1::-1])		#输出所有，倒着输出
>>> ykcul
print(str1[::-1])		#输出所有，倒着输出
>>> ykcul
print(str1[-1: 0: -1])	#倒着输出到0，因为不包含尾值，所以不包含第一个值
>>> ykcu

注意：

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

字符串的转义字符

需要在字符中使用特殊字符时，python用反斜杠（\）转义字符。如下表:

(在行尾时) 续行符 \ 反斜杠符号
’ 单引号 " 双引号
\n 换行 \t 水平制表符（4个空格）

续行符

myStr = 'abcde\
f'

格式化输出

%d %s %f 占位符

精确到小数点后3位，会四舍五入

print("num = %d, str18 = %s, f = %.3f" % (1, '焰灵姬', 3.1415))
>>> num = 1, str18 = 焰灵姬, f = 3.142	
#%	'%%'输出一个单一的'%'
print("%-10.2f" % 22.11111, '焰灵姬')
>>> 22.11      焰灵姬		#10 为10个长度 用做左对齐
print('%10.2f' % 22.1111, '焰灵姬')
>>>      22.11 焰灵姬		#10 为10个长度 用做右对齐

当值为元组的时候则会报错（因为%后有多个值是用（）括起来，中间用"，"分隔的，如果你后面直接跟一个元组，解释器就以为你是多个值，但是你前面就给一个位置，所以报错）

name = (1, 2, 3)
print("hi there %s" % name)
>>> TypeError: not all arguments converted during string formatting
# 解释器看到的：前面一个占位符，后面给三个值。
# 解释器想：你TM想干嘛，不知道对称的吗？你这样老子怎么给你显示！老子给你报错！

为了保证总是正确的你必须这样做

print("hi there %s" % (name,))	# 提供一个单元素的数组而不是一个参数

也就是哪怕只有一个值时，都要像上面那样写，这样解释器才不会看错。

使用format进行格式化

print('字符串{} 浮点数{} 整数{}'.format('asd', 11.1, 8))
>>> 字符串asd 浮点数11.1 整数8

函数	函数含义
isnumeric()	如果字符串中只包含数字字符串，则返回True，否则返回False
splitStr.join(Str)	以指定字符串作为分隔符，将Str中所有的元素合并为一个新的字符串print(’-’.join(‘abc’))
center(self,width,fillchar=None)	以原始字符串为中心生成新字符串
ljust(self, width, fillchar=None)	返回一个原字符串左对齐，并使用fillchar填充至长度width的新字符串，fillchar默认为空格。
rjust(self, width, fillchar=None)	返回一个原字符串右对齐，并使用fillchar填充至长度width的新字符串，fillchar默认为空格。
lstrip()/rstrip()/strip	截掉字符串左/右边/两侧的空格或指定字符
max(str)/min(str)	返回字符串 str 中最大/小的字母。
chr(x)	将一个整数转换为一个字符
ord(x)	将一个字符转换为它的整数值
myStr.replace(old,new[,max])	将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
find(str,beg=0,end=len)/index(str)	查找某个字符出现的位置 从左侧开始查找 查到返回索引值 查不到返回-1 /查到返回索引 查不到报错
rfind(str,beg=0,end=len)/rindex(str)	查找某个字符出现的位置 从右侧开始查找 查到返回索引值 查不到返回-1 /右查到返回索引 查不到报错
split(str=’’[,num])	num=string.count(str)) 以 str 为分隔符拆分字符串为列表，如果 num 有指定值，则仅截取 num 个子字符串
swapcase()	将字符串中大写转换为小写，小写转换为大写
upper()	转换字符串中的小写字母为大写
lower()	转换字符串中的写字母为小写
splitlines(True)	以回车换行为条件分割，参数用来设置是否保留换行

3、List（列表）

List（列表）是Python中使用最频繁的数据类型

列表时写在[]之间、用逗号分隔开的元素列表

a = [1, 2, 3, 4, 5, 6]
# 索引取值
print(a[-2])
>>> 5
# 修改值
a[0] = 9	#索引修改值
print(a)
>>> [9, 2, 3, 4, 5, 6]
a[2: 5] = [13, 14, 15]		#切片修改值
print(a)
>>> [1, 2, 13, 14, 15, 6]
# 删除值
a[2: 5] = []	#切片删除值
print(a)
>>> [1, 2, 6]
del a[2]		#索引删除值
print(a)
>>> [[1, 2, 4, 5, 6]]
# 清空列表
a.clear()
print(a)
>>> []

a = []
# 添加值
a.append(3)		#添加一个值
print(a)
>>> [3]
a.extend([1, 2, 3])		#添加多个值
print(a)
>>> [1, 2, 3]

多维列表

mylist = [[1,2,3], [4,5,6], [7,8,9]]

多维列表的取值

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

多维列表的遍历

for i in mylist:
    for x in i:
        print(x)

注意：

• 与Python字符串不一样的是，列表中的元素是可以改变；
• List写在方括号之间，元素用逗号隔开；
• 和字符串一样，list可以被索引和切片；
• List可以使用+操作进行拼接，可以使用*进行重复；

常用列表的相关函数

函数	计算列表长度
len()	计算列表的长度
list.count()	统计某个元素在列表中出现的次数
list.append()	向列表中添加一个元素
list.extend()	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index()	从列表中找出某个值第一个匹配项的索引位置
list.insert()	将对象插入列表
list.pop()	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove()	移除列表中某个值的第一个匹配项
list.reverse()	反向列表中元素
list.sort()	对原列表进行排序
list.clear()	清空列表
list.copy()	复制列表
copy.deepcopy()	深拷贝 拷贝对象及其子对象（有几层拷贝几层）
copy.copy()	浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象（只拷贝一层）

4、tuple(元组)

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。（元素， 元素， …）

元组与字符串类似，可以被索引且下标索引从0开始，-1为从末尾开始的位置。也可以进行截取

注意：

• 与字符串一样，元组的元素不能修改；
• 元组也可以被索引和切片，方法一样；
• 注意构造包含0或1个元素的元组的特殊语法规则。空元组()，一个值的元组(1,)；
• 元组也可以使用+操作符进行拼接；
• 元组的个别值不可以删除，但我们可以使用del语句来删除整个元组（其实就是删除变量）。

5、set（集合）

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

基本功能是进行成员关系测试和删除重复元素

可以使用大括号{}或者set()函数创建集合。

注意：创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典的。

a = {'a', 'b', 'c'}
b = {'a', 'b', 'd', 'e'}
print(a - b)	#a和b的差集（注意先后顺序）
>>> {'c'}
print(a | b)	#a和b的并集
>>> {'b', 'd', 'a', 'e', 'c'}
print(a & b)	#a和b的交集
>>> {'a', 'b'}
print(a ^ b)	# a和b中不同时存在的元素
>>> {'c', 'e', 'd'}

6、Dictionary(字典)

语法格式：{键： 值， 键： 值， …}

字典的取值

myDict = {'a': 1, 'b': 2}
print(myDict['a'])		# 输出键为 'a' 的值
>>> 1	
print(myDict)			# 输出完整的字典
>>> {'a': 1, 'b': 2}
myDict = {'a': 1, 'b': 2}	#输出所有键
>>> dict_keys(['a', 'b'])
print(myDict.values()		#输出所有值
dict_values([1, 2])

字典值的添加

当给原字典 添加一个不存在的键对应的值的时候，则为添加

myDict = {'name':'张三'}
myDict['age'] = 18 #将age:18添加到 字典 myDict里
print(myDict)
>>> {'name': '张三', 'age': 18}

字典值的修改

当给字典已存在的键赋新的值的时候，是对键key的值进行修改

myDict = {'name':'张三'}
myDict['name'] = '李四' #将健key  为name的 值修改为 李四
print(myDict)
>>> {'name': '李四'}

字典的值的删除

通过字典的唯一的键进行删除

myDict = {'name':'张三'}
del myDict['name']  #将健key  为name的 健值对删除
print(myDict)
>>> {}

删除字典

del 字典名
字典名.clear() #清空整个字典
del myDict['name']

构造函数dict()可以直接从键值对序列中构建字典如下：

dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
>>> {'Taobao': 3, 'Runoob': 1, 'Google': 2}
 
{x: x**2 for x in (2, 4, 6)}
>>> {2: 4, 4: 16, 6: 36}
 
dict(Runoob=1, Google=2, Taobao=3)
>>> {'Taobao': 3, 'Runoob': 1, 'Google': 2}

#想使用函数 dict 转换成 字典 前提是 必须键值对 的形式
myList = [('name', '张三'), ('age', 18), ('sex', '男'), ('hobby', '写代码')]
myList = [{'name', '张三'}, {'age', 18}, {'sex', '男'}, {'hobby', '写代码'}]
myList = [['name', '张三'], ['age', 18], ['sex', '男'], ['hobby', '写代码']]

字典的遍历

for i in mydict:
    print(i) #返回的都是键

for x,y in mydict.items(): #items() 函数以列表返回可遍历的(键, 值) 元组数组。
    print(x,y) #返回键 值

注意：

1. 字典是一种映射类型，它的元素是键值对；
2. 字典的关键字必须为不可变类型，且不能重复；（元素不能发生改变）
3. 创建空字典使用{}；
4. 列表是有序的对象结合，字典是无序的对象集合；
5. 两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取；
6. 字典是一种映射类型，字典用“{}”标识，它是一个无序的键(key)：值(value)对集合；
7. 在同一个字典中，键(key)必须是唯一的。

字典常用函数

函数	函数含义
mydict.items()	以列表返回可遍历的(键, 值) 元组数组
mydict.keys()/mydict.values()	以列表返回一个字典所有的键/以列表返回一个字典所有的值
mydict.update(dict2)	把字典dict2的键/值对更新到mydict里
mydict.pop(key)	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
mydict.popitem()	随机返回并删除字典中的一对键和值。 返回一个键值对(key,value)形式。3.6(删除字典中最后一个键值对)
mydict.copy()	返回一个字典的浅复制
deepcopy()	深复制
myDict.clear()	清空字典
myDict.get	通过键获取值

7、Python数据类型转换

函数	函数含义
int(x [,base])	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(x [,y])	将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
str(x)	将对象 x 转换为字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象（去掉引号）
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。
bool	转换为bool值