【python基础知识学习（1）】python的六大数据类型

（一）注释

单行注释

    # 这是注释，一般写一些下面代码块的功能说明 
    print('hello world')

多行注释

  '''
    这是多行注释，可以写很多很多行的功能说明哦
    哈哈
	哈哈哈哈
    哈哈哈哈哈哈哈哈。。。
    '''

中文注释

如果直接在程序中用到了中文，比如：

  print('你好')

如果直接运行输出，程序可能会报错（看python版本）。解决的办法为：在程序的开头写入如下代码。不过现在的python3已经直接支持中文注释了。

# -*- coding:utf-8 -*-
print('你好')

（二）六大数据类型

变量

在Python中，存储一个数据，需要一个叫做变量的东西，如下示例:

    num1 = 7 #num1就是一个变量，就好一个小菜篮子
    num2 = 9  #num2也是一个变量
    #把num1和num2这两个"菜篮子"中的数据进行累加，然后放到 result变量中
    result = num1 + num2

所谓变量，可以理解为购物袋，如果需要存储多个数据，最简单的方式是有多个变量，当然了也可以使用一个。
程序就是用来处理数据的，而变量就是用来存储数据的
想一想：我们应该让变量占用多大的空间，保存什么样的数据？
这就是下面要介绍的六大数据类型。

变量的类型

Numbers 数字
String 字符串
List 列表
Tuple 元组
Dictionary 字典
Set 集合

Numbers

Numbers数据类型下又分为三个子类型：

（1）整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。 注意： Python 中布尔值使用常量 True 和 False 来表示。 在数值上下文环境中，True 被当作 1，False 被当作 0，例如： True+3 >>> 4 布尔(bool)是整型的子类型。

（2）浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

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

Numbers数据类型的初始化和相互转换：

三种子类型的赋值很简单，int型以整数赋值；float型以小数赋值；complex型以a + bj赋值，复数的实部a和虚部b都是浮点型。可以使用type(变量的名字)，来查看变量的类型， 示例如下：

a= 1     # int类型数据赋值
print(type(a))
b= 1.0   # float类型数据赋值
print(type(b))
c= 3e+26J # complex类型数据赋值
print(type(c))

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

int(x) 将x转换为一个整数。

float(x) 将x转换到一个浮点数。

complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

Numbers数据类型的运算：

Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。

表达式的语法很直白： +, -, * 和 /, 和其它语言（如Pascal或C）里一样。但是有几个值得注意的地方：

在不同的机器上浮点运算的结果可能会不一样。

在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 //

// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。 （eg. 7//2.0>>>3.0)

Python 可以使用 ** 操作来进行幂运算

变量在使用前必须先"定义"（即赋予变量一个值），否则会出现错误

不同类型的数混合运算时会将整数转换为浮点数

python内置的Number类型数学函数

python内置的Number类型随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

String

字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 " )来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'
var2 = "diantou"

Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：
变量名[ 头下标 : 尾下标：步长 ]，左闭右开，示例：

var1 = 'Hello World!'
var2 = "diantou"
 
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])

注意：Python 访问字符串中的值也支持下标负索引。
Python 字符串更新
你可以截取字符串的一部分并与其他字段拼接，如下实例：

var1 = 'Hello World!' 
print ("已更新字符串 : ", var1[:6] + 'diantou!')

Python 字符串的拆分
你可以按照某个元素对字符串进行切分，方法语法：value.split(str=" ") ，如下实例：

value = 'Hello_World!' 
print ("已更新字符串 : ", value.split('_')) # ---> 已更新字符串 :  ['Hello', 'World!']

以 _ 为分隔符切片字符串value， 返回一个列表来存储分割后的字符串。
Python转义字符
在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。常见的如下：
(在行尾时) 表示续行符：

print('line1 \
… line2 \
… line3')

\ 表示反斜杠符号

print('\\')

\’ 表示单引号

print('\'')

" 表示双引号

print("\"")

Python字符串运算符
a = ‘hello’
b = ‘Python’
(1)+ 字符串连接，例如： a + b 输出结果： HelloPython
(2)* 重复输出字符串，例如： a*2 输出结果：HelloHello
Python 字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

#!/usr/bin/python3
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

python常用的字符串格式化符号:

符号	描述
%s	格式化字符串
%d	格式化整数
%f	格式化浮点数字
…	…

List

序列是 Python 中最基本的数据结构。

序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推，List也有负索引。

Python 有 6 个序列的内置类型，最常见的是列表类型。

列表都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python 已经内置函数来确定序列的长度以及确定最大和最小的元素的方法。

列表的数据项不需要具有相同的类型，啥都能装。

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

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

访问列表中的值

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

通过索引列表可以进行截取、组合等操作。

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] ) 
print( list[-2] )
print( list[-3] )

除了使用下标索引来访问列表中的值，同样你也可以使用方括号 [ 头下标 : 尾下标 ]，左闭右开的形式截取字符，如下所示：

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])
print(nums[2:-3])

更新列表

你可以对列表的数据项进行修改或更新，可以使用 append() 方法来添加列表项，如下所示：

list = ['Google', 'Runoob', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
 
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

删除列表元素

可以使用 del 语句来删除列表的的元素，如下实例：

list = ['Google', 'Runoob', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素后的列表 : ", list)

Python列表脚本操作符

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

如下所示：

嵌套列表及索引

使用嵌套列表即在列表里创建其它列表，例如：

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

print(x) #---> [['a', 'b', 'c'], [1, 2, 3]] 
print(x[0]) #---> ['a', 'b', 'c'] 
print (x[0][1]) #---> 'b'

列表比较

列表比较需要引入 operator 模块的 eq 方法（详见：Python operator 模块）：

# 导入 operator 模块
import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))

列表插入

描述
insert() 函数用于将指定对象插入列表的指定位置。

语法
insert()方法语法：

list.insert(index, obj)
参数
index – 对象obj需要插入的索引位置。
obj – 要插入列表中的对象。
返回值
该方法没有返回值，但会在列表指定位置插入对象。

实例
以下实例展示了 insert()函数的使用方法：

list1 = ['Google', 'Runoob', 'Taobao']
list1.insert(1, 'Baidu')
print ('列表插入元素后为 : ', list1)

列表统计

描述
count() 方法用于统计某个元素在列表中出现的次数。

语法
count()方法语法：

list.count(obj)
参数
obj – 列表中统计的对象。
返回值
返回元素在列表中出现的次数。

实例
以下实例展示了 count()函数的使用方法：

aList = [123, 'Google', 'Runoob', 'Taobao', 123];

print ("123 元素个数 : ", aList.count(123))
print ("Runoob 元素个数 : ", aList.count('Runoob'))

列表的排序

描述
sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

语法
sort()方法语法：

list.sort( key=None, reverse=False)

参数
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
返回值
该方法没有返回值，但是会对列表的对象进行排序。

实例
以下实例展示了 sort() 函数的使用方法：

aList = ['Google', 'Runoob', 'Taobao', 'Facebook']
 
aList.sort()
print ( "List : ", aList)

Tuple

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

元组使用小括号 ( )，列表使用方括号 [ ]。

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

创建空元组:

tup1 = ()

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

tup1 = (50)
print(type(tup1))     # 不加逗号，类型为整型

tup1 = (50,)
print(type(tup1))     # 加上逗号，类型为元组

元组的增删改查

增：元组与字符串，列表类似， 且可以进行截取，组合等，如下实例:

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz') 
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

删：元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

改：元组中的元素值是不允许修改的。

tup1 = (12, 34.56) 
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100

查：元组与字符串类似，元组的访问从下标索引从 0 开始，当然，也可以使用负索引。

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

关于元组是不可变的

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

tup = ('r', 'u', 'n', 'o', 'o', 'b')
tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

id(tup)     # 查看内存地址
4440687904
tup = (1,2,3) #重新赋值
id(tup)
4441088800    # 内存地址不一样了

从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。

Dictionary

字典是另一种可变容器模型，且可存储任意类型对象。

字典的存储单元是成对出现的（key：value） 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

# 创建空字典使用大括号 { } 创建空字典：
emptyDict = {}
# 也可以使用内建函数 dict() 创建字典：
emptyDict = dict()

字典中，键必须是唯一的，但值可以不唯一。且值可以取任何数据类型，但键必须是不可变的数据类型，如字符串，数字。

一个简单的字典实例：

tinydict = {'name': 'diantou', 'likes': 123, 'url': 'www.diantou.com'}

返回字典的键值对，Keys或 values

d = {"name":"Arwin", "age":25}
d.items()     # >>> dict_items([('name', 'Arwin'), ('age', 25)]) 返回一个包含所有（键，值）元祖的列表
d.keys()      # >>> dict_keys(['name', 'age']) 返回一个包含字典所有KEY的列表
d.values()    # >>> dict_values(['Arwin', 25]) 返回一个包含字典所有value的列表

字典的增删改查

增：向字典添加新内容的方法是增加新的键/值对，修改已有键/值对如下实例:

tinydict = {'Name':'diantou', 'Age':7, 'Class':' First'}
 
tinydict['Age'] = 9                      # 更新 Age
tinydict['School'] = "deeplearning"  # 添加信息
 
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

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

tinydict = {'Name': 'diantou', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典 

改：通过索引关键字赋值的方式修改键值。如下实例：

tinydict = {'Name': 'diantou', 'Age': 7, 'Class': 'First'}
 
tinydict['Name'] = 'Arwin'
print(tinydict)

查：通过索引关键字的方法查询键值，注意：如果用字典里没有的键访问数据，会输出错误。实例如下

tinydict = {'Name': 'Arwin', 'Age': 7, 'Class': 'First'} 
print ("tinydict['Alice']: ", tinydict['Alice'])

---error
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("tinydict['Alice']: ", tinydict['Alice'])
KeyError: 'Alice'

此外，关于字典，两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

tinydict = {'Name': 'Arwin', 'Age': 7, 'Name': 'Alice'} 
print ("tinydict['Name']: ", tinydict['Name'])

以上实例输出结果：
tinydict[‘Name’]: Alice

2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：

tinydict = {['Name']: 'Runoob', 'Age': 7} 
print ("tinydict['Name']: ", tinydict['Name'])

以上实例输出将会报错。

Set

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

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

创建格式：

parame = {'value01','value02',...}
或者
set(value)

由于集合的性质之一是存放不重复的元素，因此可以用于去重功能，实例如下：

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)                      # 这里演示的是去重功能

下面展示两个集合间的运算：

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

print(a)        #   >>>    {'a', 'r', 'b', 'c', 'd'}   天生去重
print(a - b )   #   >>>    {'r', 'd', 'b'}  集合a中包含而集合b中不包含的元素
print(a | b)    #   >>>    {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}  集合a或b中包含的所有元素
print(a & b)   	#   >>>    {'a', 'c'}  集合a和b中都包含了的元素 
print(a ^ b)    #   >>>    {'r', 'd', 'b', 'm', 'z', 'l'}  不同时包含于a和b的元素 

集合的增删改查

增：将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

tinyset = set(("Google", "Baidu", "Yamaxun"))
tinyset.add("Facebook")
print(tinyset) 

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式 ：s.update( x ) 。其中，x 可以有多个，用逗号分开，实例如下：

tinyset = set(("Google", "Runoob", "Taobao"))
tinyset.update({1,3})
print(tinyset) # >>> {1, 3, 'Google', 'Taobao', 'Runoob'}

tinyset.update([1,4],[5,6])  
print(tinyset) # >>> {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

删：将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
语法格式： s.remove( x ) 实例如下：

tinyset = set(("Google",  "Baidu", "Yamaxun"))
tinyset.remove("Yamaxun")
print(tinyset)  # >>> {'Google', 'Runoob'}

#tinyset.remove("Facebook")  # >>> 不存在会发生错误  

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式: s.discard( x )

清空集合的语法格式如下：s.clear()

改： 集合不支持索引，因此修改元素时一般把集合转换数据类型成列表型。
查： 判断元素是否在集合中存在，语法格式如下：x in s

tinyset = set(("Google", "Baidu", "Yamaxun"))
print( "Yamaxun" in tinyset) # >>> True
print( "Facebook" in  tinyset) # >>> False 

小结

（1）可变数据类型：List， Dictionary，Set。
（2）不可变数据类型：Tuple，Numbers，String。注意，一些初学者可能认为他们可变的原因实际上是这些变量名可以被重新赋值，造成了可变的假象。但是索引这些变量名中的元素是不可被重新赋值的。
（3）下标索引：所谓“下标”，就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间。下标分为正索引和负索引。字符串，列表，元组都支持下标索引。字典则是关键字索引。
（4）切片：切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。切片的语法：[起始:结束:步长]
（5）注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)。我们以字符串为例讲解。

如果取出一部分，且间隔取样，如下所示:

a = "abcdefghi" 
print(a[1:7:2] )  # ---> bdf

公共方法

Python包含了以下内置函数：