Python基础(三) 数据类型

我们首先要看的是几乎任何语言都具有的数据类型，包括字符串、整型、浮点型以及布尔类型。这些基本数据类型组成了基本控制块，从而创建的Python应用程序。

一、基本结构

1、数值:

Python支持不同的数值类型：

int (有符号整数): 通常被称为只是整数或整数，是正或负整数，不带小数点。

long (长整数 ): 或长，是无限大的整数，这样写整数，后面跟着一个大写或小写的L。

注意：自从Python2.2起，如果整数发生溢出，Python会自动将整数转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。

float (浮点实数值) : 或浮点数，表示实数，并写入一个小数点分隔的整数部分和小数部分。浮点数也可以是科学记数法，用e或E表示的功率10 (2.5e2 = 2.5 x 10² = 250).

数值类型转换：

类型int（X）将X转换为一个普通的整数。

类型long(X)将X转换为一个长整数（在python3中已经没有了这个函数）。

类型float(X)转换X为一个浮点数。

    2、布尔值:

Ture&False 即真或假、1或0.

    3、字符串：

字符串(String） 是一段文本字符，通常以某种形式向用户输出。如果我们打开Python的解释器，我们试着最常见的输出“Hello World!”应用:

 print("hello world!!")            ##python3的print()函数的方法必须加上()
 hello world!!

python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，字符串拼接使用+号进行连接，每次使用+号的时候就会在内存中重新开辟一块空间，在python中使用了下面的格式进行拼接，这种方法不会在去占用新的内存,下面来看一下字符串的格式：

 msg='''
 personal information:
      name: %s
      age:  %d'''%('alex',23)     #%s可以代表字符串，%d代表整数，还有一种为%f代表浮点数

 print(msg)

 personal information:
      name: alex
      age:  23
 #还有一种方法,这种方式要比%那种方式处理快一些，%执行要先转换成下面这种方式执行

 name = "i am {0},age {1}"
 new_name=name.format('jack',18)
 print(new_name)

字符串常用功能：

      1、移除空白：这里我们通过一个例子来说明：

  #!/usr/bin/env python

  name=input("please input your name:")
  age=input("please input your age:")
  sex=input("please input your sex:")

  print('''
       This is my message:
                name:%s
                age:%s
                sex:%s'''% (name,age,sex))

执行结果如下：　　　

 This is  my message:
             name:henry
             age:25
             sex:man

如果在用户输入信息的时候，无意输入多个空格，影响美观，我想不管用户输入多少个空格都去掉正常格式输出，这里就用到了strip()来去掉空格：

 #!/usr/bin/env python
 #coding:utf-8

 name=input("please input your name:").strip()      #还有两张用法：lstrip或rstrip(去除左边的空格，去除右边的空格)
 age=input("please input your age:").strip()
 sex=input("please input your sex:").strip()

 print('''
      This is my message:
                 name:%s
                 age:%s
                 sex:%s'''% (name,age,sex))

这样用户输入的空格就会去掉，注意：这里的strip()不会去掉中间的空格。

      2、使用split()进行字符串分割，下面来看一段代码：

 #!/usr/bin/env python
 #coding:utf-8

 s="hello World! Everyone! This Is My First String!"   ##首先定义一段字符串

 print(s.split("!"))                                   ##使用split()来以!为分割线进行分割

 ['hello World', ' Everyone', ' This Is My First String', '']    #执行结果

使用方法：

s.split([sep, [maxsplit]]) 以sep是分隔符，把s分割成一个list。sep默认为空格。maxsplit是分割的次数，默认是对整个s进行分割。
s.rsplit([sep, [maxsplit]]) 和split()的区别是它是从s的串尾往前进行分割。

3、python中使用len()来判断字符串的长度：

 name=henry              ##定义一个变量
 print(len(name))        ##使用len()来判断字符串的长度

 5                       ##执行结果

4、这里我们一起来实验一下python的索引和切片：

 name="helloworld"

 print(name[0])          ## 在字符中中每个字母对应的一个下标，从左往右以0开始，从右往左-1开始
 print(name[-1])

 print(name[0:5])        ##这里面的[0:5]代表的是截取下标0到5的字符，当然这里也可以从右往左
 print(name[-5:])

二、高级结构

（一）、列表(list)

首先我们来看一下怎么创建列表：

 name_list=['Henry','tom','seven']
 name_list=list(['Henry','tom','seven'])      #上面那种方法会调用下面这个来实现的

下面来看下列表有那些基本操作：　　　　

　　1、列表的索引、分片、步长       注：列表的修改不会再内存中申请新的地址

 name=['Henry','tom','seven','alex','wusir','penny']     ##定义一个列表

 print(name[0])                   ##列表的索引跟字符串类似，在列表中的元素都对应一个下标。

 Henry                            ##执行结果

 #列表的分片

 print(name[0:4])                 ##取下标从0到4的元素

 ['Henry', 'tom', 'seven', 'alex']

 print(name[0:5:2])              ##这种方法是取下标从0到5的元素，步长为2，也就是间隔2个元素，

3 ['Henry','seven','wusir']

　　2、列表的方法

　　方法是一个与某些对象有紧密联系的函数，对象可能是列表、数字，也可能是字符串或者其他类型的对象。方法可以这样进行调用：

对象.方法（参数）下面我们一起来看一下列表的方法：

1 x=[1,2,3,4,1,2,3] 
2  >>> dir(x)
3  ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', 
'__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__',
 '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', 
'__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

　　　　  1. append:列表末尾追加新的对象。

 lst=[1,2,3]
 lst.append(4)　　　  　#会在最后追加一个字符
 lst
 [1,2,3,4]

 "_".join(name_list)   #通过“”.join()可以将列表转换成字符串
 'alex_eric_serven'
 'alex' in name_list   #in函数判断字符串在不在列表里
 True
 'jack' in name_list
 False

2.count：统计某个元素在列表中出现的次数。

 name=[1,2,3,1,5,6,3,2,1,7,8,2]
 print(name.count(1))                 ##统计1在列表中出现的次数
 3                                    ##执行结果

　　　　3.index：从列表中找出某个值第一个匹配项的索引位置。

 name="we are the knights who say ni"
 lst=name.split()                   ##将字符串以空格切片存到列表中

 print(lst.index('the'))            ##取元素the在列表中的位置下标

 2

4.insert：将对象插入到列表中。

 name="we are the knights who say ni"
 lst=name.split()
 lst.insert(1,'haha')          ##在下标1的位置上插入字符串haha，
 print(lst)

 ['we', 'haha', 'are', 'the', 'knights', 'who', 'say', 'ni'] 

　　　 5.pop:会移除列表中的一个元素（默认是最后一个），并且返回该元素的值。

 x=[1,2,3]
 x.pop()                 ##pop方法默认删除最后一个元素
 print(x)
 x.pop(0)                ##当然也可以根据下标位置进行删除
 print(x)        

注意：pop方法是唯一一个既能修改列表又能返回元素值（除了none）的列表方法。

　　　 6.remove：移除列表中某个值的第一个匹配项。

 x=[1,2,3,1]
 x.remove(1)   #删除第一个匹配到的元素
 print(x)   

 #!/usr/bin/env python
 #coding:utf-8

 x=[1,2,3,1,1,1,3,2]
 print(x.count(1))

 for i in range(x.count(1)):          ##统计出1在列表中出现的次数
         x.remove(1)                  ##循环删除

 print(x)

　　　 7.reverse：将列表中的元素反向存放：

 >>> x=[1,2,3,4,5]
 >>> x.reverse()
 >>> x
 [5, 4, 3, 2, 1]

　　　 8.sort:用于在原位置对列表进行排序，在"原位置排序"意味着改变原来的列表，从而让其中的元素按一定的顺序排列，而不是简单的返回一个已排序的列表副本。

 >>> x=[3,4,2,87,54,34,56]
 >>> x.sort()
 >>> x
 [2, 3, 4, 34, 54, 56, 87]

　　　 9.extend:可以在列表的末尾追加另一个序列中的多个值。

 a=[1,2,3,4,5]
 b=[2,3,4,5,6]
 a.extend(b)                        ##将b列表追加到a列表中

 print(a)

 [1, 2, 3, 4, 5, 2, 3, 4, 5, 6]    

　　　 10.copy:复制一份列表。

 >>> x=[1,2,3]
 >>> y=x.copy()
 >>> y
 [1, 2, 3]

（二）、元组(tuple)

元组和列表一样，也是一种序列。唯一不同是元组不能修改。

x=(1,2,3,4,5)
 dir(x)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', 
'__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', 
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

#这里可以看到元组的方法只有count和index，这里不在详细介绍使用方法

下面看一下元组和列表之间的转换：

 x=(1, 2, 3, 4)          ##定义一个元组
 y=list(x)               ##使用list()函数可以将x转换为列表存放在y中
  y
 [1, 2, 3, 4]
  type(x)
 <class 'tuple'>
 >>> type(y)
 <class 'list'>
 >>> z=tuple(y)         ##可以使用tuple()函数将列表转换成列表
 >>> z
 (1, 2, 3, 4)

（三）、字典（Dict）

字典是Python中唯一内建的映射类型，在字典中的值没有特殊的顺序，但是都存储在一个特定的键（Key）下。键可以是数字、字符串甚至是元组。

1、字典的特点：

1，key-value格式，key是唯一的。

2，无序，与列表有序的特点不同，字典是无序的，列表只所以有序是因为你需要通过索引来定位相应元素，而字典已经可以通过key来定位相对应value，因此为了避免浪费存储空间，

字典不会对数据的位置进行记录，当然如果你想让其变成有序的，也是可以切换的。

3，查询速度快，dict是基于hash表的原理实现的，是根据关键字（key-alue）而直接访问在内存存储位置的数据结构。也就是说，它通过把键值通过一个函数的计算，映射到一个表中

一个位置累访问记录，还加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。

2、dict的语法格式：

 >>> info={'name':'henry',
 ...        'job':'IT',
 ...        'age':'',
 ...        'company':'xlwb'}
 >>> info
 {'age': '', 'job': 'IT', 'company': 'xlwb', 'name': 'henry'

3、dict的方法：

>>> info.
info.__class__(         info.__ge__(            info.__len__(           info.__setitem__(       info.items(
info.__contains__(      info.__getattribute__(  info.__lt__(            info.__sizeof__(        info.keys(
info.__delattr__(       info.__getitem__(       info.__ne__(            info.__str__(           info.pop(
info.__delitem__(       info.__gt__(            info.__new__(           info.__subclasshook__(  info.popitem(
info.__dir__(           info.__hash__           info.__reduce__(        info.clear(             info.setdefault(
info.__doc__            info.__init__(          info.__reduce_ex__(     info.copy(              info.update(
info.__eq__(            info.__iter__(          info.__repr__(          info.fromkeys(          info.values(
info.__format__(        info.__le__(            info.__setattr__(       info.get(  

 >>> info
 {'age': '', 'job': 'IT', 'company': 'xlwb', 'name': 'henry'}
 >>> info['name']               ##查看key为'name'的value
 'henry'
 >>> info['job']='Boss'         ##将key的value改为'Boss'
 >>> info
 {'age': '', 'job': 'Boss', 'company': 'xlwb', 'name': 'henry'}
 >>> info['city']='BJ'          ##如果dict中有key为'city',就将其值改为'BJ'，如果没有这个key，就创建一条新记录
 >>> info
 {'age': '', 'city': 'BJ', 'job': 'Boss', 'company': 'xlwb', 'name': 'henry'}

 >>> info
 {'age': '', 'city': 'BJ', 'job': 'Boss', 'company': 'xlwb', 'name': 'henry'}
 >>> info.pop('age')           ##删除key为‘age’的数据，跟del info['age']一样
 ''
 >>> info.popitem()       　　 ##随机删除一条数据，dict为空时用此语法会报错。
 ('city', 'BJ')
 >>> info
 {'job': 'Boss', 'company': 'xlwb', 'name': 'henry'}

 >>> info
 {'city': 'BJ', 'job': 'Boss', 'company': 'xlwb', 'name': 'henry'}
 >>> info.items()        　　  ##将dict的key，value转换成列表的形式显示
 dict_items([('city', 'BJ'), ('job', 'Boss'), ('company', 'xlwb'), ('name', 'henry')])

 >>> info.get('age')
 >>> info.get('name')          ##查找key，如果存在返回其value，否则返回None
 'henry'

 >>> info.fromkeys(['a','b','c'],'Test')   ##根据列表['a','b','c']来创建dict里的key，后面的‘Test’是默认的value，如果不指定的话则为None
 {'a': 'Test', 'c': 'Test', 'b': 'Test'}

 >>> info.clear()    　　　　　　 ##清空字典
 >>> info
 {}

 >>> info=info.fromkeys(['a','b','c'],'Test')           #info.fromkeys()可以已列表的方式打印出所有的key值，info.fromvalues()打印出所有的value值
 >>> info
 {'a': 'Test', 'c': 'Test', 'b': 'Test'}
 >>> info.setdefault('d','Henry')     ##找一个key为'd'的记录，如果这个key不存在，那就创建一个叫'd'的key，并且将value设置为'Henry'，如果这个key存在，就直接返回key值。 'Henry'
 >>> info
 {'d': 'Henry', 'a': 'Test', 'c': 'Test', 'b': 'Test'}
 >>> info.setdefault('c','Henry')
 'Test'

 >>> info
 {'d': 'Henry', 'a': 'Test', 'c': 'Test', 'b': 'Test'}
 >>> dict2={'e':'fromDict2','a':'fromDict2'}
 >>> info.update(dict2)     ##拿这个新字典去更新info，注意dict2中有一个key值'a'与dict info相冲突，这时dict2的值会覆盖info中的a，如果dict2的key在info中不存在，则创建相应的记录。 >>> info
 {'b': 'Test', 'd': 'Henry', 'e': 'fromDict2', 'a': 'fromDict2', 'c': 'Test'}

4、遍历&copy字典：

遍历字典dict与遍历列表差不多，只不过记得dict是key-value的结构，要想在遍历时同时打印这key和value,需要这样写：

 #!/usr/bin/env python
 #coding:utf-8

 info={                                  ##定义info dict
     'name':'Henry',
     'age':25,
     'job':'IT',
     'company':'xlwb'
     }
 for item in info:
     print(item,info[item])             ##print(item)只会打印key，如果想同时打印value，需要通过item去取

 #另一种方法
 for key,val in info.items():
     print(key,val)

　　 以上是默认把字典转换成一个大列表，并且把每对key-value值转换成了元组，所以你可以在每次循环时赋2个变量进去，因为循环的数据格式如下：

　　　　[('age', 25), ('job', 'IT'), ('name', 'Henry'), ('company', 'xlwb')]

　　因此每循环依稀，其实就是把相对应元组中的2个值赋值key，val这两个变量并打印。