python如何查看数据类型_python中如何看数据类型

如何利用Python语言对字典数据类型进行各种作

>>> d['Jone'] = 99

步print 'Directory. '，声明一个字典tree，赋值name和sale键，并打印字典值

python如何查看数据类型_python中如何看数据类型

python如何查看数据类型_python中如何看数据类型

第二步，添加字典键值对，字典是由键值对来构成的，声明一个字典hudi并赋值；再次利用该字典添加一个键值对，然后打印添加后的值

第三步，对添加的键值对进行修改键值，获取age这个键，然后重新赋值，打印修改后的结果

第四步，打印hudi字典，利用del删除字典color键值对，然后打印删除后的结果

第五步，再次打印hudi字典，利用clear()方法删除该字典所有的键值对

第六步，利用pop()方法对字典键值对进行删除18，isupper() 判断是否大写，会先打印出删除的键值对！

python变量类型有哪些

逗[外链转存失败,源站可能有防盗链机制,建议将保存下来直接上传(img-j1SHxY8y-1637655972909)(C:Users14051AppDataRoamingTypora ypora-user-imagesimage-20211114192949607.png)]号隔开两个索引

Python 变量类型

变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。

1、变量赋值：Python 中的变量赋值不需要类型声明。

2、多个变量赋值

3、标准数据类型：在内存中存储的数据可以>>> print d有多种类型。

4、Python数字：数字数据类型用于存储数值。

Python支持四种不同的数字类型：int（有符号整型）、long（长整型[也可以代表八进制和十六进制]）、float（浮点型）、complex（复数）

5、Python字符串：字符串或串(String)是由数字、字母、下划线组成的一串字符。

6、Python列表：List（列表） 是 Python 中使用频繁的数据类型。

8、Python 字典字典(dictionary)是除列表以外python之中灵活的内置数据结构类型。列表是有序的对象，字典是无序的对象。

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

Python模块的几种类型

>>> d['NewList'] = [12, 23, 'Jack']

view plaincopy to clipboardprint?

[3.14, 'China', 19.998]

import os

import stat

import time

fileStats = os.stat ( 'test.txt' )

'Size' : fileStats [ statfileInfo = {.ST_SIZE ],

'LastModified' : time.ctime ( fileStats [ stat.ST_MTIME ] ),

'LastAccessed' : time.ctime ( fileStats [ stat.ST_ATIME ] ),

'CreationTime' : time.ctime ( fileStats [ stat.ST_CTIME ] ),

'Mode' : fileStats [ stat.ST_MODE ]

}for Field, Value in fileInfo:

if stat.S_ISDIR ( fileStats [ stat.ST_MODE ] ):

else:

print 'Non-directory.'

import os

import stat

import time

fileStats = os.stat ( 'test.txt' )

'Size' : fileStats [ stat.ST_SIZE ],

'LastModified' : time.ctime ( fileStats [ stat.ST_MTIME ] ),

'LastAccessed' : time.ctime ( fileStats [ stat.ST_ATIME ] ),

'CreationTime' : time.ctime ( fileStats [ stat.ST_CTIME ] ),

'Mode' : fileStats [ stat.ST_MODE ]

}for Field, Value in fileInfo:

if stat.S_ISDIR ( fileStats [ stat.ST_MODE ] ):

else:

print 'Non-directory.'

python基本语法

>>> L.pop(0)

python语法如下：

1、Python标识符

在Python7，count 返回这个值在列表中数量：list.count(value)里，标识符有字母、数字、下划线组成。

在Python中，所有标识符可以包括英文、数字以及下划线（_），但不能以数字开头。

Python中的标识符是区分大小写的。

以下划线开头的标识符是有特殊意义的。以单下划线开头_foo的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用from xxx import而导入。

以双下划线开头的foo代表类的私有成员；以双下划线开头和结尾的foo代表Python里特殊方法专用的标识，如init__（）代表类的构造函数。

2、Python有五个标准的数据类型

Numbers（数字）String（字符串）List（列表）Tuple（元组）Dictionary（字典）。

Python支持四种不同的数支持切片作list[start,stop,step]字类型：int（有符号整型）long（长整型[也可以代表八进制和十六进制]）float（浮点型）complex（复数）。

python的字串列表有2种取值顺序：从左到右索引默认0开始的，范围是字符串长度少1；从右到左索引默认-1开始的，范围是字符串开头；List（列表）是Python中使用频繁的数据类型。

列表可以完成大多数类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。列表用[]标识，是python通用的复合数据类型。

列表中值的切割也可以用到变量[头下标：尾下标]，就可以截取相应的列表，从左到右索引默认0开始，从右到左索引默认-1开始，下标可以为空表示取到头或尾。加号+是列表连接运算符，星号是重复作。元组是另一个数据类型，类似于List（列表）。

元组用“（）”标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

列表是有序的对象结合，字典是无序的对象。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典用“{}”标识。字典由索引（key）和它对应的值value组成。

Python数据分析： 初识Pandas，理解Pandas实现和原理

python 里面分为 基本数据类型 和 复合数据类型

本文的文字及来源于网络,仅供学习、交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时以作处理

整数

01 重要的前言

这段时间和一些做数据分析的同学闲聊，我发现数据分析技能入门阶段存在一个普遍性的问题，很多凭着兴趣入坑的同学，都能够很快熟悉Python基础语法，然后不约而同的一头扎进《利用Python进行数据分析》这本经典之中，硬着头皮啃完之后，好像自己什么都会了一点，然而实际作起来既不知从何起，又漏洞百出。

至于原因嘛，理解不够，实践不够是两条老牌的拦路虎，只能靠自己来克服。还有一个非常有意思且经常被忽视的因素——陷入举三反一的懵逼状态。

什么意思呢？如我是个旱鸭子，想去学游泳，教练很认真的给我剖析了蛙泳的动作，扶着我的腰让我在水里划拉了5分钟，接着马上给我讲解了蝶泳，又是划拉了5分钟，然后又硬塞给我潜泳的姿势，依然是划拉5分钟。，教练一下子把我丢进踩不到底的泳池，给我呐喊助威。

作为一个还没入门的旱鸭子，教练倾囊授了我3种游泳技巧，让我分别实践了5分钟。这样做的结果就是我哪一种游泳技巧也没学会，只学会了喝水。当一个初学者一开始就陷入针对单个问题的多种解决方法，而每一种方法的实践又浅尝辄止，在面对具体问题时往往会手忙脚乱。

拿Pandas来说，它的多种构造方式，多种索引方式以及类似效果的多种实现方法，很容易把初学者打入举三反一的懵逼状态。所以，尽量避开这个坑也是我写Pandas基础系列的初衷，希望通过梳理和精简知识点的方式，给需要的同学一些启发。目前暂定整个基础系列分为4篇，基础篇过后便是有趣的实战篇。

下面开始进入正题（我真是太唠叨了）。

02 Pandas

江湖上流传着这么一句话——分析不识潘（PANDAS），纵是老手也枉然。

Pandas是基于Numpy的专业数据分析工具，可以灵活高效的处理各种数据集，也是我们后期分析案例的神器。它提供了两种类型的数据结构，分别是DataFrame和Series，我们可以简单粗暴的把DataFrame理解为Excel里面的一张表，而Series就是表中的某一列，后面学习和用到的所有Pandas骚作，都是基于这些表和列进行的作（关于Pandas和Excel的形象关系，这里我的张俊红写的《对比EXCEL，轻松学习Python数据分析》)。

这里有一点需要强调，Pandas和Excel、SQL相比，只是调用和处理数据的方式变了，核心都是对源数据进行一系列的处理，在正式处理之前，更重要的是谋定而后动，明确分析的意义，理清分析思路之后再处理和分析数据，往往事半功倍。

03 创建、读取和存储

1、创建

在Pandas中我们想要构造下面这一张表应该如何作呢？

别忘了，步一定是先导入我们的库——import pandas as pd

构造DataFrame常用的方式是字典+列表，语句很简单，先是字典外括，然后依次打出每一列标题及其对应的列值（此处一定要用列表），这里列的顺序并不重要：

左边是jupyter notebook中dataframe的样子，如果对应到excel中，他就是右边表格的样子，通过改变columns,index和values的值来控制数据。

PS,如果我们在创建时不指定index，系统会自动生成从0开始的索引。

2、 读取

更多时候，我们是把相关文件数据直接读进PANDAS中进行作，这里介绍两种非常接近的读取方式，一种是CSV格式的文件，一种是EXCEL格式（.xlsx和xls后缀）的文件。

读取csv文件：

engine是使用的分析引擎，读取csv文件一般指定python避免中文和编码造成的报错。而读取Excel文件，则是一样的味道：

非常easy，其实read_csv和read_excel还有一些参数，比如header、sep、names等，大家可以做额外了解。实践中数据源的格式一般都是比较规整的，更多情况是直接读取。

3、存储

存储起来一样非常简单粗暴且相似：

04 快速认识数据

这里以我们的案例数据为例，迅速熟悉查看N行，数据格式概览以及基础统计数据。

1、查看数据，掐头看尾

很多时候我们想要对数据内容做一个总览，用df.head()函数直接可以查看默认的前5行，与之对应，df.tail()就可以查看数据尾部的5行数据，这两个参数内可以传入一个数值来控制查看的行数，例如df.head(10)表示查看前10行数据。

df.()帮助我们一步摸清各列数据的类型，以及缺失情况：

从上面直接可以知道数据集的行列数，数据集的大小，每一列的数据类型，以及有多少条非空数据。

3、统计信息概览

快速计算数值型数据的关键统计指标，像平均数、中位数、标准等等。

我们本来有5列数据，为什么返回结果只有两列？那是因为这个作只针对数值型的列。其中count是统计每一列的有多少个非空数值，mean、std、min、max对应的分别是该列的均值、标准、小值和值，25%、50%、75%对应的则是分位数。

05 列的基本处理方式

这里，我们采用SQL四宝的逻辑来简单梳理针对列的基本处理方式——增、删、选、改。

温馨提示：使用Pandas时，尽量避免用行或者EXCEL作单元格的思维来处理数据，要逐渐养成一种列向思维，每一列是同宗同源，处理起来是嗖嗖的快。

1、增

增加一列，用df[‘新列名’] = 新列值的形式，在所以如果我们要判断一个元素是否在一些不同的条件内符合，用set是的选择，下面例子：原数据基础上赋值即可：

2、删：

我们用drop函数制定删除对应的列，axis = 1表示针对列的作，inplace为True，则直接在源数据上进行修改，否则源数据会保持原样。

3、选：

想要选取某一列怎么办？df[‘列名’]即可：

选取多列呢？需要用列表来传递：df[[‘列’,‘第二列’,‘第三列’…]]

4、 改：

好事多磨，复杂的针对特定条件和行列的筛选、修改，放在后面结合案例细讲，这里只讲一下简单的更改：df[‘旧列名’] = 某个值或者某列值，就完成了对原列数值的修改。

06 常用数据类型及作

1、字符串

字符串类型是常用的格式之一了，Pandas中字符串的作和原生字符串作几乎一毛一样，不同的是需要在作前加上".str"。

小Z温馨提示：我们初用df2.()查看数据类型时，非数值型的列都返回的是object格式，和str类型深层机制上的区别就不展开了，在常规实际应用中，我们可以先理解为object对应的就是str格式，int64对应的就是int格式，float64对应的就是float格式即可。

在案例数据中，我们发现来源明细那一列，可能是系统导出的历史遗留问题，每一个字符串前面都有一个“-”符号，又丑又无用，所以把他给拿掉：

一般来说清洗之后的列是要替换掉原来列的：

2、 数值型

数值型数据，常见的作是计算，分为与单个值的运算，长度相等列的运算。

以案例数据为例，源数据访客数我们是知道的，现在想把所有渠道的访客都加上10000，怎么作呢？

只需要选中访客数所在列，然后加上10000即可，pandas自动将10000和每一行数值相加，针对单个值的其他运算（减乘除）也是如此。

列之间的运算语句也非常简洁。源数据是包含了访客数、转化率和客单价，而实际工作中我们对每个渠道贡献的销售额更感兴趣。（销售额 = 访客数 X 转化率 X 客单价）

对应作语句：df[‘销售额’] = df[‘访客数’] df[‘转化率’] df[‘客单价’]

但为什么疯狂报错？

导致报错的原因，是数值型数据和非数值型数据相互计算导致的。PANDAS把带“%”符号的转化率识别成字符串类型，我们需要先拿掉百分号，再将这一列转化为浮点型数据：

要注意的是，这样作，把9.98%变成了9.98，所以我们还需要让支付转化率除以100，来还原百分数的真实数值：

然后，再用三个指标相乘计算销售额：

3、时间类型

PANDAS中时间序列相关的水非常深，这里只对日常中基础的时间格式进行讲解，对时间序列感兴趣的同学可以自行查阅相关资料，深入了解。

以案例数据为例，我们这些渠道数据，是在2019年8月2日提取的，后面可能涉及到其他日期的渠道数据，所以需要加一列时间予以区分，在EXCEL中常用的时间格式是’2019-8-3’或者’2019/8/3’，我们用PANDAS来实现一下：

在实际业务中，一些时候PANDAS会把文件中日期格式的字段读取为字符串格式，这里我们先把字符串’2019-8-3’赋值给新增的日期列，然后用to_datetime()函数将字符串类型转换成时间格式：

转换成时间格式（这里是datetime64）之后，我们可以用处理时间的思路高效处理这些数据，比如，我现在想知道提取数据这一天离年末还有多少天（‘2019-12-31’），直接做减法（该函数接受时间格式的字符串序列，也接受单个字符串）：

Python其实很简单 第五章 基本数据类型

指定行标签删除

编程的目的就是为了处理信息，信息则是由各种不同类型的数据表示的，对数据的进一步处理也会使信息更加丰富和有效。

2、 格式查看

5.1变量

前面已经提到过“变量”这属语，下面再进一步解释一下。

在程序运行时，必须把数据导入计算机的存储单元中，但存储单元的命名是用二进制数表示的，晦涩难懂。为了方便起见，可以给存储单元起上一个通俗易懂的名字，即 变量名 。

变量的生命周期和程序的运行周期是相同的，一个程序运行解释，所占用的存储空间也就随之释放，用变量名表示的数据所占用的这个存储单元也就空闲了。

变量名的命名规则：

由字母、数字、下划线构成，必须由字Python是一种弱数据类型语言，可以通过给变量重新赋值的方法改变数据类型。但有时为了强制改变数据类型，就要使用类型转换函数来改变。母开头。

不能包含-、、？、#、、；、/、、@、%、$、空格等特殊字符。

使用有含义的英文单词或汉语拼音。

采用小写字母。

不能使用保留字（已被Python语言系统本身赋予特定意义的单词）。Python的保留字如下表所示。

Python保留字列表

Python是区分大小写的，虽然可以将一个英文单词通过字母大小写不同而作为不同变量的变量名，但从程序可读性的角度看，的确不可取。

Python是一种动态类型的语言，变量的类型由变量的值决定。换而言之，给变量赋何种类型的值，变量就是该值的类型。给变量赋值可以通过赋值号(=)来实现。如：

>>> myvar=100

>>> type(myvar)

>>> myvar='tom'

>>> type(myvar)

在这个例子中，变量myvar首先赋值为100，显而易见，100是个整数，通过type()这个函数检测，变量myvar的类型为整数类型(int)；接下来变量myvar赋值为‘tom’，通过type()这个函数检测，变量myvar的类型改变为字符串类型(str)。

不仅可以给一个变量赋值为常量，也可以赋值为另一个变量。如：

>>> a=100

>>> b=a

>>> b

100

在这个例子中，“b=a”的实际意义是，变量b和变量a指向同一个存储单元，既然是同一个存储单元，变量b和变量a本质上就是完全相同的，这就好比一个人除了本名之外，还有其他的名字，如笔名、昵称、乳名等等，虽然本质一样，但是可以在不同场合使用。

5.2关于Python的常量问题

在大多数语言中都有常量这个概念，但是Python却没有。其实仔细想想也好像没有设置常量的必要，只要一个变量的值不发生变化，即不给变量重新赋值，它的值当然不会变化，它便是个常量。

5.3基本数据类型

5.3.1整数型和浮点数

整数型(integer)，可以是正整数、负整数和0，可以是十进制、八进制、二进制等。

浮点数(float)，由整数部分和小数部分组成，主要用于处理包括小数的数。浮点数也可以用科学计数法表示。

5.3.2 字符串类型

字符串类型是由一系列的字母或者其他符号组成的数据序列，通常用单引号、双引号或三引号括起来。

用单引号和双引号括起来的字符串只能放在同一行，用三引号括起来的字符串可以分布在连续多行上。如：

name='我的名字叫王小明'

old="今年6岁"

introduce='''我想说： 我是娃

爱讲普通话

要学习写标准的汉字'''

print(name)

print(old)

print(introduce)

运行结果为：我的名字叫王小明

今年6岁

我想说： 我是娃

爱讲普通话

要学习写标准的汉字

不管是哪一种引号形式，括起来的部分是一个整体，包括空格和换行符都属于字符串的一部分。

为了保证特殊的输出效果，Python中的字符串支持转义字符，可使用反斜杠“”对一些特殊字符进行转义。常用的转义字符如下：

续行符

换行符

空水平制表符

” 双引号

’ 单引号

一个反斜杠

f 换页

其中，续行符（“”）用于当一个字符串在一行写不下时用续行符进行连接，但通常更多的采用小括号“()”即可。

如：

种方法采用续行符（“”）：

>>> str="A thousand wishes, a thousand plans and

a thousand resolutions are better than one action!"

>>> print(str)

A thousand wishes, a thousand plans and a thousand resolutions are better than one action!

第二种方法采用小括号()：

>>> str=("A thousand wishes, a thousand plans and "

"a thousand resolutions are better than one action!")

>>> print(str)

A thousand wishes, a thousand plans and a thousand resolutions are better than one action!

下面举例说明换行符(“ ”)的用法：

>>> str=" 登鹳雀楼 白日依山尽， 黄河入海流。 欲穷千里目, 更上一层楼。 "

>>> print(str)

登鹳雀楼

白日依山尽，

黄河入海流。

欲穷千里目,

更上一层楼。

下面举例说明使用转义字符输出双引号(“)的方法：

>>> str="王之涣的诗《登鹳雀楼》中这样写道:" 白日依山尽，黄河入海流。欲穷千里目,更上一层楼。""

>>> print(str)

王之涣的诗《登鹳雀楼》中这样写道:" 白日依山尽，黄河入海流。欲穷千里目,更上一层楼。"

>>>

5.3.3布尔类型

布尔类型用来表示逻辑值，所谓逻辑判断的结果，不外乎“真”或“”两种情况。在Python中“真”用True表示，“”用False表示。如果布尔类型的变量参与算数运算，则True被当作1，False被当作0。

如：

>>> result=True

>>> print(result)

True

>>> print(result+1)

2>>> result=False

>>> print(result)

False

>>> print(result+1)

15.3.4类型强制转换

譬如，为了从键盘读入成绩的数据，可以用float()函数将input()语句读入的字符串转换为浮点数，再赋值给变量score。

>>> score=input("请输入您的成绩：")

请输入您的成绩：96.5 （从键盘输入96.5）

为了计算成绩比及格线高了多少分，使用下面的命令，发现出现了错误提示如下：

>>> score-60

Traceback (most recent call last):

File " ", line 1, in

score-60

TypeError: unsupported operand type(s) for -: 'str' and 'int'

这是属于类型错误，原因是从键盘读入的成绩值（96.5）并非数值类型，不能参与算数运算。用type()函数可以进一步查询变量score的数据类型。

>>> type(score)

使用float()函数进行强制转换后，就可以解决上述问题：

>>> score=float(input("请输入您的成绩："))

请输入您的成绩：96.5

>>> score=float(score)

>>> type(score)

>>> score-60

36.5

下表列举了一些常用的类型转换函数：

Python中内置数据类型list，tuple，dict，set的区别和用法

{'mike': 12, 'jack': 19, 'print Field, ':' + Valuejone': 22, 'ivy': 17}

这篇文章主要给大家介绍了Python中内置数据类型list,tuple,dict,set的区别和用法，都是非常基础的知识，十分的细致全面，有需要的小伙伴可以参考下。

print('['+temp+']') #[我叫 心叶 今年 7 岁!]

Python语言简洁明了，可以用较少的代码实现同样的功能。这其中Python的四个内置数据类型功不可没，他们即是list, tuple, dict, set。这里对他们进行一个简明的总结。

List

字面意思就是一个，在Python中List中的元素用中括号[]来表示，可以这样定义一个List:

L = [12, 'China', 19.998]

可以看到并不要求元素的类型都是一样的。当然也可以定义一个空的List:

L = []

Python中的List是有序的，所以要访问List的话显然要通过序号来访问，就像是数组的下标一样，一样是下标从0开始：

>>> print L[0]

12

千万不要越界，否则会报错

>>> print L[3]

Traceback (most recent call last):

IndexError: list index out of range

List也可以倒序访问，通过“倒数第x个”这样的下标来表示序号，比如-1这个下标就表示倒数个元素：

>>> L = [12, 'China', 19.998]

>>> print L[-1]

19.998

-4的话显然就越界了

>>> print L[-4]

Traceback (most recent call last):

File "

", line 1, in

print L[-4]

IndexError: list index out of range

>>>

List通过内置的append()方法来添加到尾部，通过insert()方法添加到指置（下标从0开始）：

>>> L = [12, 'China', 19.998]

>>> L.append('Jack')

>>> print L

[12, 'China', 19.998, 'Jack']

>>> L.insert(1, 3.14)

>>> print L

[12, 3.14, 'China', 19.998, 'Jack']

>>>

通过pop()删除尾部元素，也可以指定一参数删除指置：

>>> L.pop()

'Jack'

>>> print L

12

>>> print L

也可以通过下标进行替换

>>> L[1] = 'America'

>>> print L

[3.14, 'America', 19.998]

Tuple

Tuple可以看做是一种“不变”的List，访问也是通过下标，用小括号（）表示：

>>> t = (3.14, 'China', 'Jason')

>>> print t

(3.14, 'China', 'Jason')

但是不能重新赋值替换：

>>> t[1] = 'America'

Traceback (most recent call last):

File "

", line 1, in

t[1] = 'America'

TypeError: 'tuple' object does not support assignment

也没有pop和insert、append方法。

可以创建空元素的tuple:

t = ()

或者单元素tuple (比如加一个逗号防止和声明一个整形歧义):

t = (3.14,)

那么tuple这个类型到底有什么用处呢？要知道如果你希望一个函数返回多个返回值，其实只要返回一个tuple就可以了，因为tuple里面的含有多个值，而且是不可变的（就像是ja里面的final）。当然，tuple也是可变的，比如:

>>> t = (3.14, 'China', 'Jason', ['A', 'B'])

>>> print t

(3.14, 'China', 'Jason', ['A', 'B'])

>>> L = t[3]

>>> L[0] = 122

>>> L[1] = 233

>>> print t

(3.14, 'China', 'Jason', [122, 233])

这是因为Tuple所谓的不可变指的是指向的位置不可变，因为本例子中第四个元素并不是基本类型，而是一个List类型，所以t指向的该List的位置是不变的，但是List本身的内容是可以变化的，因为List本身在内存中的分配并不是连续的。

Dict

Dict是Python中非常重要的数据类型，就像它的字面意思一样，它是个活字典，其实就是Key-Value键值对，类似于HashMap，可以用花括号{}通过类似于定义一个C语言的结构体那样去定义它：

>>> d = {

'Adam': 95,

'Lisa': 85,

'Bart': 59,

'Paul': 75

}>>> print d

{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}

可以看到打印出来的结果都是Key:Value的格式，可以通过len函数计算它的长度（List，tuple也可以）：

>>> len(d)

4可以直接通过键值对方式添加dict中的元素：

{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}

{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Jone': 99, 'Bart': 59}

List和Tuple用下标来访问内容，而Dict用Key来访问： (字符串、整型、浮点型和元组tuple都可以作为dict的key)

>>> print d['Adam']

95

如果Key不存在，会报错：

>>> print d['Jack']

Traceback (most recent call last):

File "

", line 1, in

print d['Jack']

KeyError: 'Jack'

所以访问之前先查询下key是否存在：

>>> if 'Adam' in d : print 'exist key'

exist key

或者直接用保险的get方法：

>>> print d.get('Adam')

95

>>> print d.get('Jason')

None

至于遍历一个dict，实际上是在遍历它的所有的Key的，然后用这个Key来获得对应的Value:

>>> for key in d : print key, ':', d.get(key)

Lisa : 85

Paul : 75

Adam : 95

Bart : 59

Dict具有一些特点：

查找速度快。无论是10个还是10万个，速度都是一样的，但是代价是耗费的内存大。List相反，占用内存小，但是查找速度慢。这就好比是数组和链表的区别，数组并不知道要开辟多少空间，所以往往开始就会开辟一个大空间，但是直接通过下标查找速度快；而链表占用的空间小，但是查找的时候必须顺序的遍历导致速度很慢

没有顺序。Dict是无顺序的，而List是有序的，所以不能用Dict来存储有序

Key不可变，Value可变。一旦一个键值对加入dict后，它对应的key就不能再变了，但是Value是可以变化的。所以List不可以当做Dict的Key，但是可以作为Value:

{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Jone': 99, 'Bart': 59}

{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 99, 'Lisa': 85, 'Paul': 75}

Key不可重复。（下面例子中添加了一个'Jone':0，但是实际上原来已经有'Jone'这个Key了，所以仅仅是改了原来的value）

{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 99, 'Lisa': 85, 'Paul': 75}

>>> d['Jone'] = 0

{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 0, 'Lisa': 85, 'Paul': 75}

Dict的合并，如何将两个Dict合并为一个，可以用dict函数：

>>> d2 = {'jone':22, 'ivy':17}

>>> dMerge = dict(d1.s() + d2.s())

>>> print dMerge

或者

>>> dMerge2 = dict(d1, d2)

>>> print dMerge2

方法2比方法1速度快很多，方法2等同于：

>>> dMerge3 = dict(d1)

>>> dMerge3.update(d2)

>>> print dMerge

set

>>> s = set(['A', 'B', 'C'])

就像dict是无序的一样，set也是无序的，也不能包含重复的元素。

对于访问一个set的意义就仅仅在于查看某个元素是否在这个里面：

>>> print 'A' in s

True

>>> print 'D' in s

False

大小写是敏感的。

也通过for来遍历：

s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])

#tuple

for x in s:

print x[0],':',x[1]

>>>

Lisa : 85

Adam : 95

Bart : 59

通过add和remove来添加、删除元素（保持不重复），添加元素时，用set的add()方法：

>>> s = set([1, 2, 3])

>>> s.add(4)

>>> print s

set([1, 2, 3, 4])

如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了：

>>> s = set([1, 2, 3])

>>> s.add(3)

>>> print s

set([1, 2, 3])

删除set中的元素时，用set的remove()方法：

>>> s = set([1, 2, 3, 4])

>>> s.remove(4)

>>> print s

set([1, 2, 3])

如果删除的元素不存在set中，remove()会报错：

>>> s = set([1, 2, 3])

>>> s.remove(4)

Traceback (most recent call last):

KeyError: 4

months = set(['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec',])

x1 = 'Feb'

x2 = 'Sun'

if x1 in months:

print 'x1: ok'

else:

print 'x1: error'

if x2 in months:

print 'x2: ok'

else:

print 'x2: error'

>>>

x1: ok

x2: error

python如何把字符串中的不同数据类型的人分出来

print(val_arr) #['Made', 'China', 'Made', 'China']

python这样把字符串中的不同数据类型的人分出来：

[12, 3.14, 'China', 19.998]

1、将字符串拆分为单词列表，使用split()函数按空格进行分割，将字符串拆分为含有不同人名的列表。

2、迭代列表中的每个元素，并使用适当的类7、Python元组：元组是另一个数据类型，类似于List（列表）。型转换功能分类为不同的数据类型。Python是一种高级、通用、解释型的编程语言，具有简洁、易读的语法和强大的功能，被广泛应用于各个领域，包括软件开发、数据分析、科学计算、人工智能等。

python3种数据类型

一，Python的列表list类型表示的数据：

Python3 中有六个标准的数据类型：Number（数字） + String（字符串） + List（列表） + Tuple（元组） + Sets（） + Dictionary（字典）。

Number（数字）

数字类型是顾名思义是用来存储数值的，需要记住的是，有点和Ja的字符串味道不多，如果改变了数字数据类型的值，将重新分配内存空间。

可以使用del语句删除一些数字对象的引用：del var1[,var2[,var3[....,varN]]]]。

Python 支持三种不同的数值类型：

1.整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Pytup3 = "a", "b", "c", "d";thon2 的 Long 类型。

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

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

数字类型转换

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

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

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

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

额外说明

和别的语言一样，数字类型支持各种常见的运算，不过python的运算比别的大多数常见语言都更加丰富，此外，还有大量丰富的方法，提供更高效的开发。

String（字符串）

创建字符串

创建字符串可以使用单引号、双引号、三单引号和三双引号，其中三引号可以多行定义字符串，有点类似ES6中的反引号。

Python 不支持单字符类型，单字符也在Python也是作为一个字符串使用。

访问字符串中的值

和ES一样，可以使用方括号来截图字符串，例子如下：

print(val_str[0]) #y

print(val_str[1:3]) #el

print(val_str[:3]) #yel

print(val_str[:5]) #yello

字符串运算符

字符串格式化

temp="我叫 %s 今年 %d 岁!" % ('心叶', 7)

如上所示，字符串支持格式化，当然，出来上面用到的%s和%d以外，还有一些别的，具体看文档；是不是感觉有点C语言的味道。

额外说明

所有的字符串都是Unicode字符串（针对python3），有很多有用的方法，真的很有ES和C结合体的味道。

List（列表）

序列是Python中基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，个索引是0，第二个索引是1，依此类推。

列表其实类似数组，具体的一些作就很像字符串（类似ES中数组和字符串的关系）。

常见运算

下面用一个例子来展示一些常见的运算：

val_arr=['Made','in','China']

del val_arr[1]

print(val_arr) #['Made', 'China']

print(len(val_arr)) #2

val_newarr=val_arr+[':rmation']

print(val_newarr) #['Made', 'China', ':rmation']

val_arr=val_arr2

print('in' in val_arr) #False

print('Made' in val_arr) #True

for row in val_newarr:

print(row, end=" - ") #Made - China - :rmation -

print(val_newarr[-1]) #:rmation

print(val_newarr[1:]) #['China', ':rmation']

再来看一个有用的例子：

cols=3

rows=2

list_2d = [[0 for col in range(cols)] for row in range(rows)]

print(list_2d) #[[0, 0, 0], [0hex(x) 将一个整数转换为一个十六进制字符串, 0, 0]]

嵌套列表

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

loop_arr=['yelloxing','心叶']

result_arr=[loop_arr,'同级别']

print(result_arr) #[['yelloxing', '心叶'], '同级别']

列表的嵌套就很灵活，此外随便提一下：和前面说的一样，也有很多方法提供高效的开发。

Tuple（元组）

元组与列表类似，不同之处在于元组的元素不能修改，元组使用小括号，列表使用方括号。

创建

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

tup1 = ('Google', 'Runoob', 1997, 2000);

tup2 = (1, 2, 3, 4, 5 );

print(tup1) #('Google', 'Runoob', 1997, 2000)

print(tup2) #(1, 2, 3, 4, 5)

print(tup3) #('a', 'b', 'c', 'd')

基本作

和列表的作很相似，下面说一个几天特殊的地方：

1.del可以删除某个元组，不过不可以删除元组的某个条目。

2.不可以修改，或许元组会更快，感觉的，没有实际测试。

3.由于元组不可以修改，虽然同样有一些方法，不过和修改相关的方法就没有了。

Sets（）

回想一下数学里面的，合、交、、补等运算是不是一下子回想起来了，这里的也有这些方法。

和Ja的类似，一个无序不重复元素集（与列表和元组不同，是无序的，也无法通过数字进行索引）。

更具体的说明，如果必要会在单独说明。

Dictionary（字典）

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

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中，键必须是的，但值则不必。

和ES中的JSON的不多，作也很像，不过区别也很大，内置方法很多，具体还是一样，看文档去。

删除字典元素

可以用del删除一个条目或字典，也可以用clear()方法清空字典（比如现在有字段dict，就是：dict.clear()）。

python基础教程-数据类型详解

二，python整数和浮点型支持常规的数值运算

python提供了多种的数据类型，用来存放数据。其中数据类型中又包括：字符串，布尔类型，整数，浮点数，数字，列表，元组，字典，日期。

1、字符串

a='this is string'print aa="this is string"print aa='''this is stringthis is stringthis is string'''print a

布尔类型

常见的用于循环判断中

a=int(80.9741)print a

浮点数

a= float(80.974)print a

字符类型的转换

int(x [,base]) 将x转换为一个整数

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

complex(real [,imag]除了上面已经说明的方括号，还有一些别的字符串运算，具体查看文档。) 创建一个复数

str(x) 将对象x转换为字符串

repr(x) 将对象x转换为表达式字符串

eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象

tuple(s) 将序列s转换为一个元组

list(s) 将序列s转换为一个列表

chr(x) 将一个整数转换为一个字符

unichr(x) 将一个整数转换为Unicode字符

ord(x) 将一个字符转换为它的整数值

oct(x) 将一个整数转换为一个八进制字符串

列表查看特定列的书库类型

L1 = [1,2,3]print L1L2 = ['abc']print L2L3 = ["a","b","c"]print L3L = list("Python")print Lprint L[0]print L[3]print L[-1]

Python的元组与列表类似，不同之处在于元组的元素不能修改；元组使用小括号()，列表使用方括号[]；元组创建很简单，只需要在括号中添加元素，并使用逗号(,)隔开即可，例如：

tup1 = ('physics', 'chemistry', 1997, 2000);

tup2 = (1, 2, 3, 4, 5 );

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

字典由键和对应的值组成。字典也被称作关联数组或哈希表。基本语法如下：

dict = {'Al': '2341', 'B': '02', 'Cecil': '3258'};

时间日期

import time, datetime;localtime = time.localtime(time.time())today = datetime.date.today()print "Local current time :", today