python的类是什么

python中bool运算符按优先级顺序分别有or、and、not, 其中or、and为短路运算符

not先对表达式进行真值测试后再取反

not运算符值只有1个表达式，not先对表达式进行真值测试后再取反,返回的结果不是True就是False

or、and运算符返回的结果是操作符两边的表达式中的符合逻辑条件的其中一个表达式的结果

在其它语言中，比如C#，bool运算的结果肯定也是bool值;但是python中不是这样的，它返回的是满足bool运算条件的其中一个表达式的值。

x or y：

若 x为True,则结果为x;若x为False, 则结果为y。

x and y：

若 x为False,则结果为x;若x为True, 则结果为y。

or、and运算符是短路运算符

短路运算符的意思是，运算符左右的表达式的只有在需要求值的时候才进行求值。比如说x or y，python从左到右进行求值，先对表达式x的进行真值测试，如果表达式x是真值，根据or运算符的特性，不管y表达式的bool结果是什么，运算符的结果都是表达式x，所以表达式y不会进行求值。这种行为被称之为短路特性。

or、and运算符可以多个组合使用，使用的时候将以此从左到右进行短路求值，最后输入结果

表达式x or yand z，会先对x or y进行求值，然后求值的结果再和z进行求值，求值过程中依然遵循短路原则。

not运算符的优先级比or、and高，一起使用的时候，会先计算not，再计算or、and的值

not运算符的优先级比==、!=低，not a == b 会被解释为 not (a == b)， 但是a == not b 会提示语法错误。

找工作难？那是你没选对行业!

2017年【中公教育】特别推出2017年就业促进计划，500万就业基金助你成为IT达人

详情请戳：http//ujiuye/zt/jycj/?wt.bd=bgz

什么？海量IT学习资料白给你都不要？别想了，加群抢：584539956

变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。

基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。

因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。

变量赋值

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

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。

每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-counter = 100# 赋值整型变量miles = 1000.0# 浮点型name = "John"# 字符串printcounterprintmilesprintname

运行实例

以上实例中，100，1000.0和"John"分别赋值给counter，miles，name变量。

执行以上程序会输出如下结果：

1001000.0John

多个变量赋值

Python允许你同时为多个变量赋值。例如：

a = b = c = 1

以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。

您也可以为多个对象指定多个变量。例如：

a, b, c = 1, 2, "john"

以上实例，两个整型对象1和2的分配给变量 a 和 b，字符串对象 "john" 分配给变量 c。

标准数据类型

在内存中存储的数据可以有多种类型。

例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。

Python 定义了一些标准类型，用于存储各种类型的数据。

Python有五个标准的数据类型：

Numbers（数字）

String（字符串）

List（列表）

Tuple（元组）

Dictionary（字典）

Python数字

数字数据类型用于存储数值。

他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。

当你指定一个值时，Number对象就会被创建：

var1 = 1

var2 = 10

您也可以使用del语句删除一些对象的引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]]

您可以通过使用del语句删除单个或多个对象的引用。例如：

del var

del var_a, var_b

Python支持四种不同的数字类型：

int（有符号整型）

long（长整型[也可以代表八进制和十六进制]）

float（浮点型）

complex（复数）

实例

一些数值类型的实例：

intlongfloatcomplex

1051924361L0.03.14j

100-0x19323L15.2045.j

-7860122L-21.99.322e-36j

0800xDEFABCECBDAECBFBAEl32.3e+18.876j

-0490535633629843L-90.-.6545+0J

-0x260-052318172735L-32.54e1003e+26J

0x69-4721885298529L70.2E-124.53e-7j

长整型也可以使用小写 l，但是还是建议您使用大写 L，避免与数字 1 混淆。Python使用 L 来显示长整型。

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

Python字符串

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

一般记为 :

s="a1a2···an"(n>=0)

它是编程语言中表示文本的数据类型。

python的字串列表有2种取值顺序:

从左到右索引默认0开始的，最大范围是字符串长度少1

从右到左索引默认-1开始的，最大范围是字符串开头

如果你要实现从字符串中获取一段子字符串的话，可以使用变量[头下标:尾下标]，就可以截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

比如:

s = 'ilovepython'

s[1:5]的结果是love。

当使用以冒号分隔的字符串，python返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。

上面的结果包含了s[1]的值l，而取到的最大范围不包括上边界，就是s[5]的值p。

加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-str = 'Hello World!'printstr# 输出完整字符串printstr[0]# 输出字符串中的第一个字符printstr[2:5]# 输出字符串中第三个至第五个之间的字符串printstr[2:]# 输出从第三个字符开始的字符串printstr * 2# 输出字符串两次printstr + "TEST"# 输出连接的字符串

以上实例输出结果：

Hello World!Hllollo World!Hello World!Hello World!Hello World!TEST

Python列表

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

列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。

列表用[ ]标识，是 python 最通用的复合数据类型。

列表中值的切割也可以用到变量[头下标:尾下标]，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

加号+是列表连接运算符，星号*是重复操作。如下实例：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-list = ['runoob', 786 , 2.23, 'john', 70.2]tinylist = [123, 'john']printlist# 输出完整列表printlist[0]# 输出列表的第一个元素printlist[1:3]# 输出第二个至第三个元素 printlist[2:]# 输出从第三个开始至列表末尾的所有元素printtinylist * 2# 输出列表两次printlist + tinylist# 打印组合的列表

以上实例输出结果：

['runoob', 786, 2.23, 'john', 70.2]runoob[786, 2.23][2.23, 'john', 70.2][123, 'john', 123, 'john']['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

Python元组

元组是另一个数据类型，类似于List（列表）。

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

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-tuple = ('runoob', 786 , 2.23, 'john', 70.2)tinytuple = (123, 'john')printtuple# 输出完整元组printtuple[0]# 输出元组的第一个元素printtuple[1:3]# 输出第二个至第三个的元素 printtuple[2:]# 输出从第三个开始至列表末尾的所有元素printtinytuple * 2# 输出元组两次printtuple + tinytuple# 打印组合的元组

以上实例输出结果：

('runoob', 786, 2.23, 'john', 70.2)runoob(786, 2.23)(2.23, 'john', 70.2)(123, 'john', 123, 'john')('runoob', 786, 2.23, 'john', 70.2, 123, 'john')

以下是元组无效的，因为元组是不允许更新的。而列表是允许更新的：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-tuple = ('runoob', 786 , 2.23, 'john', 70.2)list = ['runoob', 786 , 2.23, 'john', 70.2]tuple[2] = 1000# 元组中是非法应用list[2] = 1000# 列表中是合法应用

Python 字典

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

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-dict = {}dict['one'] = "This is one"dict[2] = "This is two"tinydict = {'name': 'john','code':6734, 'dept': 'sales'} printdict['one']# 输出键为'one' 的值printdict[2]# 输出键为 2 的值printtinydict# 输出完整的字典printtinydict.keys()# 输出所有键printtinydict.values()# 输出所有值

输出结果为：

This is oneThis is two{'dept': 'sales', 'code': 6734, 'name': 'john'}['dept', 'code', 'name']['sales', 6734, 'john']

Python数据类型转换

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

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数描述

int(x [,base])

将x转换为一个整数

long(x [,base] )

将x转换为一个长整数

float(x)

将x转换到一个浮点数

complex(real [,imag])

创建一个复数

str(x)

将对象 x 转换为字符串

repr(x)

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

eval(str)

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

tuple(s)

将序列 s 转换为一个元组

list(s)

将序列 s 转换为一个列表

set(s)

转换为可变集合

dict(d)

创建一个字典。d 必须是一个序列 (key,value)元组。

frozenset(s)

转换为不可变集合

chr(x)

将一个整数转换为一个字符

unichr(x)

将一个整数转换为Unicode字符

ord(x)

将一个字符转换为它的整数值

hex(x)

将一个整数转换为一个十六进制字符串

oct(x)

将一个整数转换为一个八进制字符串

欢迎关注【软件测试的艺术】，和小编一起学习交流IT技术。

大家好，今天我们一起聊聊Python“类”之继承，说到这个题目，其实我不是特别喜欢，也纠结了几个小时，“所有官方的教程里面都是继承，可我认为在某些程度上遗传更贴切”，文章的封面也选了好久，最终决定了这张亲子图。正式讲之前，和大家聊聊这些，我想对于内容的理解应该会有所帮助。

首先，我们定义一个animal动物的类（就把自己当Python界的造物主吧，现在你正在创建animal）：

接下来想创造dog，dog也会eat和sleep，于是身为造物主的我们偷懒了，“eat和sleep，animal就有，能不能从它那儿继承过来”，当然可以啊，大家请看：

我们猜猜看，会输出什么结果，为什么dog类连初始化函数也没有，这样子可以吗？大家先看运行结果

dog继承了animal遗传给它的eat和sleep方法，并调用了animal的初始化方法，好吧，这么大的恩情，所以理所应当的，dog就是儿子，即子类，animal就是爹，即父类。

创造完dog，于是造物主的我们手又痒痒了，现在着手创建cat吧：

这回，又会有什么输出结果呢？

发现什么没，cat调用的是自己的初始化方法和eat方法，这就像拒绝继承皇位的王子，想靠自己的意志活出不一样的人生。这在Python里，叫做方法重载，也就是子类根据自己的需要，重写父类中的方法。

然后呢，再创造一个会飞的哺乳动物，蝙蝠bat：

bat类继承自animal类和bird类，在Python里，这叫做多重继承，就像小孩继承了父母双方的基因，既聪明又漂亮；bat类还生成自己独特的方法focus，下面我们一起看一下运行结果。

1、继承语法 class 子类名（父类名1，父类名2，...）：

2、子类可以创建自己独有的方法

3、方法调用时，子类先在本类中查找调用的方法，找不到才去父类中按次序找，即在父类1中找到了就不去父类2中找了，这一点可以从bat类的初始化方法中看出。

4、子类可以重写继承自父类中的方法，即方法重载，方法调用时，优先调用子类中重载过的方法，比如上述代码中的eat方法。

今天的Python大餐就先到这儿，大家回去好好消化，等着你的会是更美味可口，敬请享用。

探究更多的类属性，在一些初学者的教程中，一般很少见。我之所以要在这里也将这部分奉献出来，就是因为本教程是“From Beginner to Master”。当然，不是学习了类的更多属性就能达到 Master 水平，但是这是通往 Master 的一步，虽然在初级应用中，本节乃至于后面关于类的属性用的不很多，但是，这一步迈出去，你就会在实践中有一个印象，以后需要用到了，知道有这一步，会对项目有帮助的。俗话说“艺不压身”。

__dict__

读者是否思考过一个问题：类或者实例属性，在 Python 中是怎么存储的？或者为什么修改或者增加、删除属性，我们能不能控制这些属性？

用 dir() 来查看一下，发现不管是类还是实例，都有很多属性，这在前面已经反复出现，有点见怪不怪了。不过，这里我们要看一个属性：__dict__，因为它是一个保存秘密的东西：对象的属性。

为了便于观察，我将上面的显示结果进行了换行，每个键值对一行。

对于类 Spring 的__dict__属性，可以发现，有一个键'season'，这就是这个类的属性；其值就是类属性的数据。

用这两种方式都能得到类属性的值。或者说 Spring.__dict__['season'] 就是访问类属性。下面将这个类实例化，再看看它的实例属性：

实例属性的__dict__是空的。有点奇怪？不奇怪，接着看：

这个其实是指向了类属性中的 Spring.season，至此，我们其实还没有建立任何实例属性呢。下面就建立一个实例属性：

>>> s.season = "the spring of instance"

>>>s.__dict__

{'season': 'the spring of instance'}

这样，实例属性里面就不空了。这时候建立的实例属性和上面的那个 s.season 只不过重名，并且把它“遮盖”了。这句好是不是熟悉？因为在讲述“实例属性”和“类属性”的时候就提到了。现在读者肯定理解更深入了。

此时，那个类属性如何？我们看看：

Spring 的类属性没有受到实例属性的影响。

按照前面的讲述类属性和实例熟悉的操作，如果这时候将前面的实例属性删除，会不会回到实例属性s.__dict__为空呢？

果然打回原形。

当然，你可以定义其它名称的实例属性，它一样被存储到__dict__属性里面：

诚然，这样做仅仅是更改了实例的__dict__内容，对 Spring.__dict__无任何影响，也就是说通过 Spring.lang 或者 Spring.__dict__['lang'] 是得不到上述结果的。

那么，如果这样操作，会怎样呢？

在类的__dict__被更改了，类属性中增加了一个'flower'属性。但是，实例的__dict__中如何？

没有被修改。我也是这么想的，哈哈。你此前这这么觉得吗？然而，还能这样：

这个读者是否能解释？其实又回到了前面第一个出现 s.season 上面了。

通过上面探讨，是不是基本理解了实例和类的__dict__，并且也看到了属性的变化特点。特别是，这些属性都是可以动态变化的，就是你可以随时修改和增删。

属性如此，方法呢？下面就看看方法（类中的函数）。

结果跟前面讨论属性差不多，方法 tree 也在__dict__里面呢。

又跟前面一样。虽然建立了实例，但是在实例的__dict__中没有方法。接下来，执行：

在类(3)中有一部分内容阐述“数据流转”，其中有一张图，其中非常明确显示出，当用上面方式执行方法的时候，实例 t 与 self 建立了对应关系，两者是一个外一个内。在方法中 self.x = x，将 x 的值给了 self.x，也就是实例应该拥有了这么一个属性。

果然如此。这也印证了实例 t 和 self 的关系，即实例方法(t.tree('xiangzhangshu'))的第一个参数(self，但没有写出来)绑定实例 t，透过 self.x 来设定值，即给 t.__dict__添加属性值。

换一个角度：

这回方法中没有将 x 赋值给 self 的属性，而是直接 return，结果是：

是不是理解更深入了？

现在需要对 Python 中一个观点：“一切皆对象”，再深入领悟。以上不管是类还是的实例的属性和方法，都是符合 object.attribute 格式，并且属性类似。

当你看到这里的时候，要么明白了类和实例的__dict__的特点，要么就糊涂了。糊涂也不要紧，再将上面的重复一遍，特别是自己要敲一敲有关代码。（建议一个最好的方法：用两个显示器，一个显示器看本教程，另外一个显示器敲代码。事半功倍的效果。）

需要说明，我们对__dict__的探讨还留有一个尾巴：属性搜索路径。这个留在后面讲述。

不管是类还是实例，其属性都能随意增加。这点在有时候不是一件好事情，或许在某些时候你不希望别人增加属性。有办法吗？当然有，请继续学习。

__slots__

首先声明，__slots__能够限制属性的定义，但是这不是它存在终极目标，它存在的终极目标更应该是一个在编程中非常重要的方面：优化内存使用。

仔细看看 dir() 的结果，还有__dict__属性吗？没有了，的确没有了。也就是说__slots__把__dict__挤出去了，它进入了类的属性。

这里可以看出，类 Spring 有且仅有两个属性。

实例化之后，实例的__slots__与类的完全一样，这跟前面的__dict__大不一样了。

通过类，先赋予一个属性值。然后，检验一下实例能否修改这个属性：

看来，我们的意图不能达成，报错信息中显示，tree 这个属性是只读的，不能修改了。

因为前面已经通过类给这个属性赋值了。不能用实例属性来修改。只能：

用类属性修改。但是对于没有用类属性赋值的，可以通过实例属性：

但此时：

实例属性的值并没有传回到类属性，你也可以理解为新建立了一个同名的实例属性。如果再给类属性赋值，那么就会这样了：

当然，此时在给 t.flower 重新赋值，就会爆出跟前面一样的错误了。

这里试图给实例新增一个属性，也失败了。

看来__slots__已经把实例属性牢牢地管控了起来，但更本质是的是优化了内存。诚然，这种优化会在大量的实例时候显出效果。