注意：我使用的Python代码版本一律是3.x
数字
Python 支持三种不同的数值类型：整型(Int)、浮点型(float) 、复数( (complex)) 。
注意：Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
可以使用十六进制和八进制来代表整数：
In [66]:number = 0xA0F # 十六进制表示，以0x开头
In [67]:number
Out[67]: 2575
In [68]:number = 0o37 # 八进制表示，以0o开头
In [69]:number
Out[69]: 31```
可以使用以下下方法进行数字类型转换：
int(x)、float(x) 、complex(x)、complex(x, y)
In [71]:a = 1.0
In [72]:int(a) # 将a由浮点数转换为整数
Out[72]: 1
进行数字运算：
In [74]: 17 / 3 # 注意这里计算会和Py2.x有所不同
Out[74]: 5.666666666666667
In [75]: 17 // 3 # 整数除法返回向下取整后的结果
Out[75]: 5
In [76]: 17 % 3 # %操作符返回除数的余数
Out[76]: 2
In [77]: 5 * 3 +2
Out[77]: 17```
等号（=）用于给变量赋值，可以使用 ** 操作来进行幂运算：
In [79]: width = 20
In [80]: height = 5*9
In [81]: width * height
Out[81]: 900
In [82]: 2 ** 7
Out[82]: 128
不同类型的数混合运算时会将整数转换为浮点数：
In [83]: 3 * 3.75 / 1.5
Out[83]: 7.5
In [84]: 7.0 / 2
Out[84]: 3.5
<br /> <br />
字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。
# 创建字符串：
In [85]: var1 = 'Hello World!'
In [86]: var2 = 'Runoob'
# 用切片来截取字符串：
In [87]: var1[0]
Out[87]: 'H'
In [88]: var2[1:5]
Out[88]: 'unoo'
# 对已存在的字符串进行修改：
In [89]: var1 = var1[:6] + 'Runoob!'
In [90]: var1
Out[90]: 'Hello Runoob!'
支持格式化字符串的输出,最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
In [91]: print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
我叫 小明 今年 10 岁!
三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
In [93]: para_str = """这是一个多行字符串的实例
...: 多行字符串可以使用制表符
...: TAB ( \t )。
...: 也可以使用换行符 [ \n ]。
...: """
In [94]: print (para_str) # 这里要print出来，才会格式化输出
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [
]。
关于unicode 字符串，在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。 在Python3中，所有的字符串都是Unicode字符串。
<br /> <br />
列表
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型。列表是一种有序的集合，可以随时添加和删除其中的元素。
访问及删除列表中的元素
In [96]: list1 = ['Google', 'Runoob', 1997, 2000]
In [97]: list1[0]
Out[97]: 'Google'
In [98]: list2 = [1, 2, 3, 4, 5, 6, 7 ]
In [99]: list2[1:5]
Out[99]: [2, 3, 4, 5]
In [100]: list = ['Google', 'Runoob', 1997, 2000]
In [101]: list
Out[101]: ['Google', 'Runoob', 1997, 2000]
In [102]: del list[2]
In [103]: list
Out[103]: ['Google', 'Runoob', 2000]
列表脚本操作符
In [104]: len([1,2,3]) # 求取列表长度
Out[104]: 3
In [105]: [1,2,3]+[4,5,6] # 对列表组合
Out[105]: [1, 2, 3, 4, 5, 6]
In [106]: ['hi']*4 # 重复列表中的元素
Out[106]: ['hi', 'hi', 'hi', 'hi']
In [107]: 3 in [1,2,3] # 元素是否存在于列表中
Out[107]: True
In [108]: for x in [1, 2, 3]: print (x) # 对列表元素进行迭代
1
2
3
列表截取
In [109]: L=['Google', 'Runoob', 'Taobao']
In [110]: L[2] # 读取第三个元素
Out[110]: 'Taobao'
In [111]: L[-2] # 从右侧开始读取倒数第二个元素
Out[111]: 'Runoob'
In [112]: L[1:] # 输出从第二个元素开始后的所有元素
Out[112]: ['Runoob', 'Taobao']
列表拼接与嵌套
In [113]: squares = [1, 4, 9, 16, 25]
In [114]: squares + [36, 49, 64, 81, 100] # 对列表进行拼接
Out[114]: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
In [115]: a = ['a', 'b', 'c']
In [116]: n = [1, 2, 3]
In [117]: x = [a, n] # 对列表进行嵌套
In [118]: x
Out[118]: [['a', 'b', 'c'], [1, 2, 3]]
In [119]: x[0]
Out[119]: ['a', 'b', 'c']
In [120]: x[0][1] # 类似于二维Numpy数组
Out[120]: 'b'
列表包含以下函数
len(list) #列表元素个数
max(list) #返回列表元素最大值
min(list) #返回列表元素最小值
list(seq) #将元组转换为列表
列表包含以下方法
list.append(obj) 在列表末尾添加新的对象
list.count(obj) 统计某个元素在列表中出现的次数
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj) 将对象插入列表
list.pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj) 移除列表中某个值的第一个匹配项
list.reverse() 反向列表中元素
list.sort([func]) 对原列表进行排序
list.clear() 清空列表
list.copy() 复制列表
<br /> <br />
元组
元组与列表类似，不同之处在于元组的元素不能修改。元组使用元括号，列表使用方括号。
#创建元组
In [121]: tup1 = (1, 2, 3, 4, 5)
In [122]: tup2 = 'a','b','c','d'
In [123]: tup1
Out[123]: (1, 2, 3, 4, 5)
In [124]: tup2
Out[124]: ('a', 'b', 'c', 'd')
#创建空元组
In [125]: tup3 = ()
In [126]: tup3
Out[126]: ()
#元组中只包含一个元素时，需要在元素后面添加逗号
In [127]: tup = (50,)
In [128]: tup
Out[128]: (50,)
访问及修改元组
In [129]: tup1 = ('Google', 'Runoob', 1997, 2000)
In [130]: tup2 = (1, 2, 3, 4, 5, 6, 7 )
In [131]: tup1[0]
Out[131]: 'Google'
In [132]: tup2[1:5]
Out[132]: (2, 3, 4, 5)
In [135]: tup1 = (12, 34.56)
In [136]: tup2 = ('abc', 'xyz')
In [137]: tup3 = tup1 + tup2
In [138]: tup3
Out[138]: (12, 34.56, 'abc', 'xyz')
# tup1[0] = 100，根据索引赋值来修改元组元素操作是非法的。
#对元组中的列表元素修改是可以的。如下：
In [207]: t = (1,2,['a','b'])
In [208]: t
Out[208]: (1, 2, ['a', 'b'])
In [209]: t[2][0] = 'c'
In [210]: t
Out[210]: (1, 2, ['c', 'b'])
删除元组
#元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
In [140]: tup = ('Google', 'Runoob', 1997, 2000)
In [141]: tup
Out[141]: ('Google', 'Runoob', 1997, 2000)
In [142]:del tup #删除整个元组，再打印会出现tup没定义的提示
元组运算符
In [145]: len((1, 2, 3)) #求元组元素个数
Out[145]: 3
In [146]: (1, 2, 3) + (4, 5, 6) #对元组进行连接
Out[146]: (1, 2, 3, 4, 5, 6)
In [147]: ('Hi',) * 4 #对元组元素进行复制
Out[147]: ('Hi', 'Hi', 'Hi', 'Hi')
In [148]: 3 in (1, 2, 3) #判断元素是否存在
Out[148]: True
In [149]: for x in (1, 2, 3): print (x) #对元组元素进行迭代
1
2
3
元组索引与截取
In [150]: L = ('Google', 'Taobao', 'Runoob')
In [151]: L[2] #读取第三个元素
Out[151]: 'Runoob'
In [152]: L[-2] #反向读取，读取倒数第二个元素
Out[152]: 'Taobao'
In [153]: L[1:] #截取元素，从第二个开始后的所有元素
Out[153]: ('Taobao', 'Runoob')
元组包含了以下内置函数
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
tuple(seq) 将列表转换为元组。
元组其他Tips
#获取取item的索引，可以使用下面的遍历方法
In [194]: for index in range(len(tuple1)):
...: print (tuple1[index])
#运用内置函数enumerate来获取对应的索引和元素
In [195]: for index, item in enumerate(tuple1):
...: print ('%i, %s' % (index, item))
<br /> <br />
字典
字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中。键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组
创建及访问字典中的值
In [157]: dict3 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} #创建字典
In [158]: dict3['Name'] #通过字典中的键访问对应的值
Out[158]: 'Runoob'
In [159]: dict3['Age']
Out[159]: 7
修改字典。向字典添加新内容的方法是增加新的键/值对。
In [160]: dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
In [161]: dict['Age'] = 8
In [162]: dict['School'] = '菜鸟教程'
#可以看到已做更改和增加
In [163]: dict
Out[163]: {'Age': 8, 'Class': 'First', 'Name': 'Runoob', 'School': '菜鸟教程'}
删除字典元素、清空及删除字典
In [172]: dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
In [173]: del dict1['Name'] #删除字典元素
In [174]: dict1.clear() #清空字典，但是字典还存在，只是是空的
In [175]: dict1
Out[175]: {}
In [176]: del dict1 #删除字典，再输出字典dict1会显示未定义错误
字典键的特性
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
特性有二：
1、字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
In [178]: dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
In [179]: dict['Name']
Out[179]: '小菜鸟'
2、键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
In [180]: dict = {['Name']: 'Runoob', 'Age': 7}
#这样定义会显示错误：TypeError: unhashable type: 'list'
字典内置函数&内置方法：
len(dict) 计算字典元素个数，即键的总数。
str(dict) 输出字典以可打印的字符串表示。
type(variable) 返回输入的变量类型，如果变量是字典就返回字典类
radiansdict.clear() 删除字典内所有元素
radiansdict.copy() 返回一个字典的浅复制
radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
key in dict 如果键在字典dict里返回true，否则返回false
radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
radiansdict.keys() 以列表返回一个字典所有的键
radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
radiansdict.values() 以列表返回字典中的所有值
<br /> <br />
集合
集合（set）是一个无序不重复元素的序列。基本功能是进行成员关系测试和删除重复元素。
In [181]: student = ({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'})
In [182]: student #可以发现重复的Tom删除了
Out[182]: {'Jack', 'Jim', 'Mary', 'Rose', 'Tom'}
In [185]: a = set('abcabcef')
In [186]: b = set('abclmn')
In [187]: a
Out[187]: {'a', 'b', 'c', 'e', 'f'}
In [188]: b
Out[188]: {'a', 'b', 'c', 'l', 'm', 'n'}
#集合的一些运算
In [189]: a-b #a和b的差集
Out[189]: {'e', 'f'}
In [190]: a | b #a和b的并集
Out[190]: {'a', 'b', 'c', 'e', 'f', 'l', 'm', 'n'}
In [191]: a & b #a和b的交集
Out[191]: {'a', 'b', 'c'}
In [192]: a ^ b # a和b中不同时存在的元素
Out[192]: {'e', 'f', 'l', 'm', 'n'}
集合的其他操作
set.add(obj) # 添加新元素
#集合也存在不可变形式,frozenset为固定集合.
set3 = frozenset(list1) #创建一个固定集合，固定集合不能添加元素
# 删除元素
set2.discard(6) # 当元素不存在时,不会引发异常
set2.remove(6) # 与discard的区别在于，如果没有要删除的元素，remove会引发一个异常
set2.pop() # 因为set是无序的，所以pop会随机的从set中删除一个元素
set.update('python') #传入的元素python拆分，做为个体传入到集合中
set.remove('obj') #传入的元素做为个体从集合中全部删除
网友评论