doc

      我们首先要看的是几乎任何语言都具有的数据类型，包括字符串、整型、浮点型以及布尔类型。这些基本数据类型组成了基本控制块，从而创建的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]
5 
6 "_".join(name_list)   #通过“”.join()可以将列表转换成字符串
7 'alex_eric_serven'
8 'alex' in name_list   #in函数判断字符串在不在列表里
9 True
10 'jack' in name_list
11 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':'24',
...        'company':'xlwb'}
>>> info
{'age': '24', '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': '24', 'job': 'IT', 'company': 'xlwb', 'name': 'henry'}  
>>> info['name']               ##查看key为'name'的value
'henry'
>>> info['job']='Boss'         ##将key的value改为'Boss'
>>> info
{'age': '24', 'job': 'Boss', 'company': 'xlwb', 'name': 'henry'}
>>> info['city']='BJ'          ##如果dict中有key为'city',就将其值改为'BJ'，如果没有这个key，就创建一条新记录
>>> info
{'age': '24', 'city': 'BJ', 'job': 'Boss', 'company': 'xlwb', 'name': 'henry'}

>>> info
{'age': '24', 'city': 'BJ', 'job': 'Boss', 'company': 'xlwb', 'name': 'henry'}
>>> info.pop('age')           ##删除key为‘age’的数据，跟del info['age']一样
'24'
>>> 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值。10 '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中不存在，则创建相应的记录。22 >>> 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这两个变量并打印。