Python入门之数据类型

Python 数据类型包含有：Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Sets（集合）、Dictionary（字典）、None（空类型）、Object（对象类型）。

一. Number（数字）类型
Python3 中支持int（整型）、float（浮点型）、bool（布尔值）、complex（复数）。
举例：
int 0102 84 -237 -0X92 2994747574564765L
float 3.1424 4.2E-10 -90.
bool True False
complex 6.23+1.5j 0+1j -1.23-875J

数学小科普：

1. 0x表示这个数是十六进制的，0开头表示这个数是8进制的，1-9开头表示是十制下的数字。
2. 一万，可以写成10000,也可以写成1E4的，表示10的四次方
3. 复数比较复杂，等用到的时候再来普及

二、String（字符串）类型
Python 中的字符串用单引号（‘）或者双引号（“）括起来，同时使用反斜杠()转义特殊字符。
常见的转义字符：

转义字符	描述
\(在行尾时)	续航符
\\	反斜杠符号
\’	单引号
\’’	双引号
\a	响铃
\b	退格（backspace）
\e	转义
\000	空，终止符，其后面的字符串全部忽略
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，例如：\o12代表换行
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

1. 反斜杠可以用来转义,使用r可以让反斜杠不发生转义，如r’\tbc’就显示成’\tbc’而不会解析\t为制表符。
2. 字符串可以用+运算符连接在一起（和java一样，php用.运算符），用*运算符重复。
   例如：

str1 = ‘abc’
str2 = ’efg‘
print(str1+str2)
print(str1*2)

实际输出结果：

abcdefg
abcabc

3. Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
   例如：

str = 'abcdefg'
s1 = str[0]   	#值为'a'
s2 = str[3]  	#值为'd'
s3 = str[-1]		#值为'g'
s4 = str[-3]	#值为'e'

4. Python中的字符串不能改变，即`str[2] = ‘g’是错的，不能改变str的组成字符。
5. Python中也提供了许多字符串操作方法。
   例如：

• 去除空格或者字符串左右端的指定符
  strip()-----删除字符串两边的指定字符，括号的写入指定字符，默认为空格
  lstrip()-----删除字符串左边的指定字符，括号的写入指定字符，默认为空格
  rstrip()-----删除字符串右边指定字符，默认为空格
• 查找字符串
  find()-----返回查找匹配个数，若查找失败会返回-1，不会影响程序运行。一般用find!=-1或者find>-1来作为判断条件。
  index()-----检测字符串中是否包含子字符串str，可指定范围，查找失败会报错。
• 字符串大小写转换
  lower()-----将大写转化为小写
  upper()-----将小写转化为大写
  swapcase()-----大小写互换
  capitalize()-----首字母大写
• 字符串放入中心位置指定长度
  center()-----将字符串放入中心位置可指定长度以及位置两边字符。
  例如：

str.center()
a='hello world'
print(a.center(40,'*'))
**************hello world***************

• 字符串统计
  count()-----统计字符串中某字符的个数
• 常用字符串的测试、判断函数，这一类函数在string模块中没有，这些函数返回的都是bool值
  startswith(prefix[,start[,end]]) --判断是否以prefix开头。
  str -----检测的字符串。
  start ----- 可选参数用于设置字符串检测的起始位置。
  end ----- 可选参数用于设置字符串检测的结束位置。

str = "this is string example....wow!!!"
print(str.startswith( 'this' ))
print(str.startswith( 'is', 2, 4 ))  #匹配的只有str[2]str[3]
print(str.startswith( 'this', 2, 4 ))

实际输出结果：

True
True
False

endswith(suffix[, start[, end]])–判断是否一suffix结尾。
suffix ----- 该参数可以是一个字符串或者是一个元素。
start ----- 字符串中的开始位置。
end ----- 字符中结束位置。

str = "this is string example....wow!!!"
 
suffix = "wow!!!"
print(str.endswith(suffix))
print(str.endswith(suffix,20))
 
suffix = "is"
print(str.endswith(suffix, 2, 4)) #实际匹配的只有str[2]str[3]
print(str.endswith(suffix, 2, 6)) #实际匹配的只有str[2]str[3]str[4]str[5]

实际输出结果：

True
True
True
False

isalnum()-----是否全是字母和数字，并至少有一个字符。
isalpha() -----是否全是字母，并至少有一个字符。
isdigit()-----是否全是数字，并至少有一个字符。
isspace()-----是否全是空白字符，并至少有一个字符。
islower()-----字母是否全是小写。
isupper()-----字母是否全是大写。
istitle()-----首字母是否大写。

• 编码解码
  encode()-----以 encoding 指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。
  str.encode(encoding=‘UTF-8’,errors=‘strict’)
  encoding ----- 要使用的编码，如"UTF-8"。
  errors ----- 设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeError。 其他可能得值有 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。
  该方法返回编码后的字符串。
  decode() -----以 encoding 指定的编码格式解码字符串。默认编码为字符串编码。
  encoding ----- 要使用的编码，如"UTF-8"。
  errors ----- 设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeError。 其他可能得值有 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。
  该方法返回解码后的字符串。
  例如：

str = "this is string example....wow!!!"
str = str.encode('base64','strict')
print ("Encoded String: " + str)
print ("Decoded String: " + str.decode('base64','strict'))

实际输出结果：

Encoded String: dGhpcyBpcyBzdHJpbmcgZXhhbXBsZS4uLi53b3chISE=
Decoded String: this is string example....wow!!!

• 字符串截取
  split()-----通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串。
  str.split(str="", num=string.count(str))
  str ----- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
  num ----- 分割次数。默认为 -1, 即分隔所有。
  返回分割后的字符串列表。
  例如：

str = "Line1-abcdef \nLine2-abc \nLine4-abcd"
print(str.split( ))      # 以空格为分隔符，包含 \n
print(str.split(' ', 1 )) # 以空格为分隔符，分隔成两个

实际结果：

['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

6. Python中没有java／c／c＋＋中的字符char类型，只包含一个字符的字符串就是Python中的字符类型。
7. 字符串的截取可以用split()方法，也可以通过切片的方式截取。

str = 'abcdefg'
s = str[:3] #值为'abc'
s = str[1:3] #值为'bc'
s = str[3] #值为'd'
s = str[1:6:2] #值为'bdf'
s = str[3:] 值为'defg'

切片详解：object[start_index:end_index:step]
step：正负数均可，其绝对值大小决定了切取数据时的‘‘步长”，而正负号决定了“切取方向”，正表示“从左往右”取值，负表示“从右往左”取值。当step省略时，默认为1，即从左往右以增量1取值。
start_index：表示起始索引（包含该索引本身）；该参数省略时，表示从对象“端点”开始取值，至于是从“起点”还是从“终点”开始，则由step参数的正负决定，step为正从“起点”开始，为负从“终点”开始。
end_index：表示终止索引（不包含该索引本身）；该参数省略时，表示一直取到数据“端点”，至于是到“起点”还是到“终点”，同样由step参数的正负决定，step为正时直到“终点”，为负时直到“起点”。

三、List(列表)类型
创建空列表

l = list（）
l = []

创建普通列表

l = ['a',10,'b',1+3j,5.5]

list操作方法

l = [1,2,3,4,5]
a = [7,8]
b = [1,4,3,2,5]
l.append('6') #结果为[1, 2, 3, 4, 5, '6']
l.pop() #栈弹出最后一个值，结果为[1,2,3,4]
l.remove(3) #移除3这个值，结果为[1,2,4,5]
b.sort() #永久性排列，直接改变该list ，结果为[1,2,3,4,5]，暂时性排序采用sorted(b)，会产生一个新的序列
l.count(3) #列表中值为3的元素个数，结果为1
l.extend(a) # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表），结果为[1,2,3,4,5,7,8]
l.index(4) #查找当前列表中包含查找值的索引位置，结果为3
l.insert(2，b) #在某索引位置插入某值，结果为[1,2,b,3,4,5]

注意：

1. List写在方括号之间，元素用逗号隔开，可以包含重复元素（和java一样）。
2. 和字符串一样，list可以被索引和切片，即取元素和截取。
3. List可以使用+操作符进行拼接，也可以使用＊进行重复操作，
   例如：

l = ['a',10,'b',1 + 3j,5.5]
l2 = l + l # l2的值为：['a', 10, 'b', (1+3j), 5.5, 'a', 10, 'b', (1+3j), 5.5]
l3 ＝ l * 2 # l3的值为：['a', 10, 'b', (1+3j), 5.5, 'a', 10, 'b', (1+3j), 5.5]

4. List中的元素是可以改变的。

四、Tuple(元组)类型
创建元组

t = ()

创建普通元组

t = ('a',10,'b',1 + 3j,5.5)

读操作基本和List列表一样，需要注意的是Tuple中的元素是不能改的（只读），而List中的元素是可以改的，所以Tuple自然也就没了insert(),append(),pop(),reverse(),remove(),extend(),sort()等可能改变元组元素结构的方法了,也不能通过tuple[index] = value赋值。

注意：

1. 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
2. 可以将tuple当成一个只读的List。
3. 构造空元组可以用()，需要注意的是tuple没有tuple()方法来构建空元组，同时需要注意只包含一个元素的元组的创建规则：

nullTuple = ()    # 构建空元组
t = (10,)		#只有一个元素的元组
t = (10)		#t类型为一个整数

五、Set(集合)类型
集合(set)是一个无序不重复元素的序列。
创建空集合

s = set()

创建普通集合

s = {'a',10,'b',1 + 3j,5.5}

判断成员是否在集合中

s = {'a',10,'b',1 + 3j,5.5}
if( 'b' in s):
    print('b在集合中')
else:
    print('b不在集合中')

集合运算

s1 = {'a','b','c'}
s2 = {'b','c','e'}
print(s1 - s2) 		#a和b的差集，即在a中不在b中，结果为{'a'}
print(s1 | s2)		#a和b的并集，结果为{'e', 'b', 'a', 'c'}
print(s1 & s2)		#a和b的交集，结果为{'b', 'c'}
print(s1 ^ s2)		#a、b中不同时存在的元素，结果为{'a', 'e'}

六、Dictionary(字典)类型
字典（dictionary）是Python中另一个非常有用的内置数据类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用”{ }”标识，它是一个无序的键(key) : 值(value)对集合。键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。可以类比java的Map来学习。
创建空字典

d = dict（）
d = {}

创建普通字典

d = {1:'a','a':10,'c':'b',5.6:1 + 3j,100:5.5}

字典的内置函数

d = {1:'a','a':10,'c':'b',5.6:1 + 3j,100:5.5}
------访问字典中的值------
d[1] #获取key为1的value，结果为a,如果写了不存在的key会报错
d.get(1) #获取key为1的value，结果为a，与上面唯一的区别是，如果写了不存在的值，返回None。也可以写成d.get(1,'not found'),这样找不到存在的值，返回'not found'
d.keys() #获取所有的key值，并生成一个序列
d.values() # 或缺所有的value 值，并声称一个序列
if  'key' in d:   #判断key是否存在
    print('key')
for k,v in d.items():   #遍历字典
    print(k,v)
for k in dict:
    print(k,dict[k])
    print(k,dict.get(k))   取值速度快，性能好
------修改字典------
d['key'] = value  #key 存在即修改，key不存在即新增
d.setdefault('key',value)   #只能新增
------删除字典元素------
d.pop('key')  必须要传值，因为字典是无序的
d.popitem()  随机删除一个
del d['key'] 
d.clear()  清空字典

注意：
字典是一种映射类型，它的元素是键值对 ,类似java的Map。
字典的键必须为不可变类型，且不能重复。
创建空字典使用 { }。

七、None(空)类型
有点类似java中的null，c／c＋＋中的NULL，但None类型不能用于计算，因为它不像True,Flase一样代表一个数字。

八、Object(对象)类型
Python中的所有数据类型都是Object类型，还可以自己自定义类型，也就是创建类。

[参考链接]
(https://blog.csdn.net/ydxlt/article/details/51097823)