Python的数据类型

Python的主要数据类型有：Number（数字），String（字符串类型），布尔值，List（列表），Tuple（元组）和Dictionary（字典）。

1.数字（Number）

数字包括整数和浮点数

1.1 数字类型的创建

a = 5
b = a
b = 10

print(a)
print(b)

结果是：

a = 5
b = 10

1.2 Number 类型转换

var1 = 1.23
var2 = 4
var3 = int(var1)
var4 = int(var2)
print(var3,var4)

结果：

1 4

 #abs(x)    返回数字的绝对值，如abs(-10) 返回 10
 # ceil(x)    返回数字的上入整数，如math.ceil(4.1) 返回 5
 # cmp(x, y)    如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
 # exp(x)    返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
 # fabs(x)    返回数字的绝对值，如math.fabs(-10) 返回10.0
 # floor(x)    返回数字的下舍整数，如math.floor(4.9)返回 4
 # log(x)    如math.log(math.e)返回1.0,math.log(100,10)返回2.0
 # log10(x)    返回以10为基数的x的对数，如math.log10(100)返回 2.0
 # max(x1, x2,...)    返回给定参数的最大值，参数可以为序列。
 # min(x1, x2,...)    返回给定参数的最小值，参数可以为序列。
 # modf(x)    返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
 # pow(x, y)    x**y 运算后的值。
 # round(x [,n])    返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
 # sqrt(x)    返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j

Python内置数字函数

2.字符串类型（string）

字符串是用单引号‘’或者双引号“”括起来的任意文本，比如'qwer'，"135"等。引号是字符串的表示方式，并不是字符串的一部分，在Python中单引号和双引号没有区别，只有在当字符串中出现类似Let's go等形式时，用双引号括起来"Let's go"，注意空格也是字符串的一部分。

2.1 创建字符串

 str1 = 'Hello World!'
 str2 = 'Good Night!'

字符串操作：

 #1  * 重复输出字符串
 print('abc'*2)
 执行结果：abcabc

 #2  [:]通过索引获取字符串
 print('goodnight'[2:])
 执行结果：
 odnight

 #3  in 成员运算符，如果字符串中包含给定的字符返回 True
 print('ood' in 'goodnight')
 执行结果：
 True

 #4  % 格式化输出字符串
 print('Tom is a good boy')
 print('%s is a good boy'%'Tom')
 执行结果：
 Tom is a good boy
 Tom is a good boy

 #5  + 字符串拼接
 a = 'abc'
 b = ''
 c1 = a + b
 print(c1)
 执行结果：
 abc123
 该方法效率低，用join方法效率高：
 c2 = ''.join([a,b])
 print(c2)
 执行结果：
 abc123

Python的内置方法：

 # string.capitalize()                                  把字符串的第一个字符大写
 # string.center(width)                                 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
 # string.count(str, beg=0, end=len(string))            返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
 # string.decode(encoding='UTF-8', errors='strict')     以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace'
 # string.encode(encoding='UTF-8', errors='strict')     以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
 # string.endswith(obj, beg=0, end=len(string))         检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
 # string.expandtabs(tabsize=8)                         把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
 # string.find(str, beg=0, end=len(string))             检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
 # string.index(str, beg=0, end=len(string))            跟find()方法一样，只不过如果str不在 string中会报一个异常.
 # string.isalnum()                                     如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
 # string.isalpha()                                     如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
 # string.isdecimal()                                   如果 string 只包含十进制数字则返回 True 否则返回 False.
 # string.isdigit()                                     如果 string 只包含数字则返回 True 否则返回 False.
 # string.islower()                                     如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
 # string.isnumeric()                                   如果 string 中只包含数字字符，则返回 True，否则返回 False
 # string.isspace()                                     如果 string 中只包含空格，则返回 True，否则返回 False.
 # string.istitle()                                     如果 string 是标题化的(见 title())则返回 True，否则返回 False
 # string.isupper()                                     如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
 # string.join(seq)                                     以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
 # string.ljust(width)                                  返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
 # string.lower()                                       转换 string 中所有大写字符为小写.
 # string.lstrip()                                      截掉 string 左边的空格
 # string.maketrans(intab, outtab])                     maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
 # max(str)                                             返回字符串 str 中最大的字母。
 # min(str)                                             返回字符串 str 中最小的字母。
 # string.partition(str)                                有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
 # string.replace(str1, str2,  num=string.count(str1))  把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
 # string.rfind(str, beg=0,end=len(string) )            类似于 find()函数，不过是从右边开始查找.
 # string.rindex( str, beg=0,end=len(string))           类似于 index()，不过是从右边开始.
 # string.rjust(width)                                  返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
 # string.rpartition(str)                               类似于 partition()函数,不过是从右边开始查找.
 # string.rstrip()                                      删除 string 字符串末尾的空格.
 # string.split(str="", num=string.count(str))          以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
 # string.splitlines(num=string.count('\n'))            按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
 # string.startswith(obj, beg=0,end=len(string))        检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
 # string.strip([obj])                                  在 string 上执行 lstrip()和 rstrip()
 # string.swapcase()                                    翻转 string 中的大小写
 # string.title()                                       返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
 # string.translate(str, del="")                        根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
 # string.upper()                                       转换 string 中的小写字母为大写

python内置方法

3.布尔值

布尔值只有两种状态，True或False，要么是True，要么是False。（注意大小写）

print(4>2)
print(4<2)
执行结果：
True
False

布尔值经常用在条件判断中：

 num = 5
 if num > 3:
     print('bigger')
 else:
     print('smaller')
 执行结果：
 bigger

4.列表（List）

列表是Python中最常用的数据类型之一，用中括号[]来解析列表。通过列表可以对数据方便的存储、修改等操作。

定义列表

 lis = ['Tom',1,'jack','abc']

通过下标访问列表中的元素，下标从0开始计数

 >>> lis = ['Tom',1,'jack','abc']
 >>> lis[0]
 'Tom'
 >>> lis[1]
 1
 >>> lis[2]
 'jack'
 >>> lis[3]
 'abc'

一些操作：

1.查（[]）

  >>> lis = ['Tom',1,'jack','abc','cat','Dota']
  >>> lis[1:4]    #取下标1至4之间的元素，包括1，不包括4
  [1, 'jack', 'abc']
  >>> lis[1:-1]    #取下标1到-1的元素，不包括-1.-1代表列表从右往左数的第一个元素
  [1, 'jack', 'abc', 'cat']
  >>> lis[0:3]    #取下标0至3的元素
  ['Tom', 1, 'jack']
  >>> lis[:3]    #和上边结果一样，如果从头开始，0可以忽略
  ['Tom', 1, 'jack']
  >>> lis[3:]    #从下标为3的元素取到最后一个元素
  ['abc', 'cat', 'Dota']
  >>> lis[3:-1]    #从下标为3的元素取到倒数第二个元素，取左不取右
  ['abc', 'cat']
  >>> lis[0::2]    #从下标为0的元素取，每隔一个元素去一个
  ['Tom', 'jack', 'cat']
  >>> lis[::2]    #和上边效果一样，从头开始0可以忽略
  ['Tom', 'jack', 'cat']

查

2.增（append.insert）

append方法用于将对象追加到列表结尾，insert可以指定插入位置。

 lis = ['Tom',1,'jack','abc','cat','Dota']
 lis.append('lol')
 print(lis)
 执行结果：
 ['Tom', 1, 'jack', 'abc', 'cat', 'Dota', 'lol']

 lis = ['Tom',1,'jack','abc','cat','Dota']
 lis.insert(1,'lol')  #1是指定插入位置的下标
 print(lis)
 执行结果：
 ['Tom', 'lol', 1, 'jack', 'abc', 'cat', 'Dota'] 

3.改（重新赋值）

 lis = ['Tom',1,'jack','abc','cat','Dota']
 lis[3] = 'kong'
 print(lis)
 执行结果：
 ['Tom', 1, 'jack', 'kong', 'cat', 'Dota']

 lis = ['Tom',1,'jack','abc','cat','Dota']
 lis[0:2] = ['liu','mu']
 print(lis)
 执行结果：
 ['liu', 'mu', 'jack', 'abc', 'cat', 'Dota']

4.删（remove,del,pop）

remove指定元素删除

 lis = ['Tom',1,'jack','abc','cat','Dota']
 lis.remove('Tom')
 print(lis)
 执行结果：
 [1, 'jack', 'abc', 'cat', 'Dota']

pop指定下标删除，并返回被删除的内容，默认删除最后一个元素

 lis = ['Tom',1,'jack','abc','cat','Dota']
 b = lis.pop(0)
 print(lis)
 print(b)
 执行结果：
 [1, 'jack', 'abc', 'cat', 'Dota']
 Tom

del指定下标删除，可以指定范围删除

 lis = ['Tom',1,'jack','abc','cat','Dota']
 del lis[0:3]
 print(lis)
 执行结果：
 ['abc', 'cat', 'Dota']

5.其他操作

5.1 count 统计

 lis = ['Tom','jack','abc','Tom','cat','Dota']
 print(lis.count('Tom'))
 执行结果：
 2

5.2 extend 扩展，在列表末尾一次性加入另一个列表的所有元素

lis = ['Tom','jack','abc','Tom','cat','Dota']
a = ['lol','word']
lis.extend(a)
print(lis)
执行结果：
['Tom', 'jack', 'abc', 'Tom', 'cat', 'Dota', 'lol', 'word']

5.3 index列出某个元素第一次出现的下标

 lis = ['Tom','jack','abc','Tom','cat','Dota']
 print(lis.index('Tom'))
 print(lis.index('jack'))
 执行结果：
 0
 1

5.4 reverse将列表中元素倒置排列

lis = ['Tom','jack','abc','Tom','cat','Dota']
lis.reverse()
print(lis)
执行结果：
['Dota', 'cat', 'Tom', 'abc', 'jack', 'Tom']

5.5 sort由大到小排序，字符串以首字母在ASCII码表中位置排序

 lis = [5,8,2,3,1,9]
 lis.sort()
 print(lis)
 执行结果：
 [1, 2, 3, 5, 8, 9]

5.6 copy拷贝

浅拷贝

 names_class1=['张三','李四','王五','赵六',[1,2,3]]
 names_class1_copy=names_class1.copy()
 print(names_class1)
 print(names_class1_copy)
 执行结果：
 ['张三', '李四', '王五', '赵六', [1, 2, 3]]
 ['张三', '李四', '王五', '赵六', [1, 2, 3]]

5.元组（tuple）

元组和列表差不多，同样用于存一组数，不同的是，元组一旦创建就不可修改，又叫只读列表。

虽然元组中的元素不可修改，但当列表作为元组的元素时，此列表中的元素可改。

语法

 names = ('xiaofang','laoliu','cuihua')

当元组中只有一个元素时，元素后加逗号（,）

name = ('xiaofang',)

他只有2个方法，count和index用法和上边的列表一样。

6.字典（Dictionary）

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过下标存取。

创建字典

 dic1={'name':'xiaoliu','age':27,'sex':'male'}
 dic2=dict((('name','xiaoliu'),))
 print(dic1)
 print(dic2)
 执行结果：
 {'age': 27, 'name': 'xiaoliu', 'sex': 'male'}
 {'name': 'xiaoliu'}

操作：

1.查

 dic={'name':'xiaoliu','age':27,'sex':'male'}
 print(dic['name'])
 print(dic['names'])  #没有键报错
 执行结果：
 xiaoliu
 KeyError: 'names'

 dic={'name':'xiaoliu','age':27,'sex':'male'}
 print(dic.get('age'))
 print(dic.get('ages'))  #没有键返回None
 执行结果：
 27
 None

 dic={'name':'xiaoliu','age':27,'sex':'male'}
 print(dic.items())
 print(dic.keys())
 print(dic.values())
 print(list(dic.keys()))
 执行结果：
 dict_items([('age', 27), ('name', 'xiaoliu'), ('sex', 'male')])
 dict_keys(['age', 'name', 'sex'])
 dict_values([27, 'xiaoliu', 'male'])
 ['name', 'sex', 'age']

 print('name' in dic)
 执行结果：
 True

2.增

 dic3 = {}
 dic3['name'] = 'xiaoliu'
 dic3['age'] = 18
 print(dic3)
 执行结果：
 {'name': 'xiaoliu', 'age': 18}

 a = dic3.setdefault('name','yuan')
 b = dic3.setdefault('age',22)
 print(a,b)
 print(dic3)
 执行结果：
 xiaoliu 18
 {'name': 'xiaoliu', 'age': 18}

3.删

 dic={'name':'xiaoliu','age':27,'sex':'male'}
 dic.clear()  #清空字典

 del dic['name']
 print(dic)
 执行结果：
 {'sex': 'male', 'age': 27}

 del dic  #删除字典

 a = dic.pop('name')  #删除选中的键和值，并返回值
 print(a,dic)
 执行结果：
 xiaoliu {'sex': 'male', 'age': 27}

 a = dic.popitem()  #任意删除一组键值，并返回键值
 print(a,dic)
 执行结果：
 ('name', 'xiaoliu') {'age': 27, 'sex': 'male'}

4.改

 dic={'name':'xiaoliu','age':27,'sex':'male'}
 dic['name'] = 'liyang'
 print(dic)
 执行结果：
 {'name': 'liyang', 'sex': 'male', 'age': 27}

 dic={'name':'xiaoliu','age':27,'sex':'male'}
 dic1 = {'hobby':'girl','age':23}  #dic中没有的添加，有相同键的更新
 dic.update(dic1)
 print(dic)
 执行结果：
 {'name': 'xiaoliu', 'age': 23, 'hobby': 'girl', 'sex': 'male'}

5.其他操作和方法

5.1 dict.fromkeys()

 d1 = dict.fromkeys(['name1','name2','name3'],'Tom')
 d2=dict.fromkeys(['host1','host2','host3'],['Mac','huawei'])
 print(d1)
 print(d2)
 执行结果：
 {'name2': 'Tom', 'name3': 'Tom', 'name1': 'Tom'}
 {'host3': ['Mac', 'huawei'], 'host1': ['Mac', 'huawei'], 'host2': ['Mac', 'huawei']}

5.2 d.copy()对字典浅复制，返回一个和d有相同键值对的新字典

5.3 字典的嵌套

 dic = {'city':{'beijing':'chaoyang','shanghai':'pudong'},
        'fruit':['banana','apple'],'country':'chinese'}
 print(dic['city']['beijing'])
 执行结果：
 chaoyang

5.4 字典的遍历

 dic={'name':'xiaoliu','age':27,'sex':'male'}
 for i in dic:
     print(i,dic[i])
 执行结果：
 name xiaoliu
 sex male
 age 27

 dic={'name':'xiaoliu','age':27,'sex':'male'}
 for item in dic.items():
     print(item)
 执行结果：
 ('name', 'xiaoliu')
 ('age', 27)
 ('sex', 'male')

 dic={'name':'xiaoliu','age':27,'sex':'male'}
 for key,values in dic.items():
     print(key,values)
 执行结果：
 age 27
 sex male
 name xiaoliu

5.5 sorted(dic) 将字典的key有序的排列成一个字典

 dic={5:'',2:'',4:''}
 print(sorted(dic))
 >>>
 [2,4,5]

7.集合

集合是无序的不重复元素的集，是python的基本数据类型。集合的主要作用是去重和关系测试。

集合用大括号“{}”表示，但是空集合不能用“{}”表示，只能用set()，前者会创建一个空字典。

 se1 = {}
 se2 = set()
 print(type(se1))
 print(type(se2))
 >>>:
 <class 'dict'>
 <class 'set'>

1. 集合中的元素必须是可哈希的

 se = {[1,2],3,4}
 print(se)
 >>>:
 TypeError: unhashable type: 'list'

2. 去重

 se = {1,3,4,1,5,'a','a','c','c','b',5}
 print(se)
 >>>:
 {1, 'c', 3, 4, 5, 'a', 'b'}

 se = 'aabbccddee'
 se1 = set(se)
 print(se1)
 >>>:
 {'c', 'd', 'b', 'e', 'a'}

3. 关系测试

 a = set([1,2,3,4,5])
 b = set([3,4,5,6,7])

 #父集
 print(a > b) #>>>:False  a不在b中
 print(a in b) #>>>:False  a不在b中
 print(b > a) #>>>:False  b不在a中
 print(b in a) #>>>:False  b不在a中

 #差集
 print(a.difference(b)) #>>>:{1, 2}  在a不在b
 print(a - b) #{1, 2}

 print(b.difference(a)) #>>>:{6, 7}  在b不在a
 print(b - a) #{6, 7}

 print(a.symmetric_difference(b)) #>>>:{1, 2, 6, 7}  对称差集，反向交集
 print(a ^ b) #>>>:{1, 2, 6, 7}

 #并集
 print(a.union(b)) #>>>:{1, 2, 3, 4, 5, 6, 7}
 print(a | b) #>>>:{1, 2, 3, 4, 5, 6, 7}

 #交集
 print(a.intersection(b)) #>>>:{3, 4, 5}
 print(a & b) #>>>:{3, 4, 5}