python类型定义

A. python定义模型

学python的人都知道，python中一切皆是对象，如class生成的对象是对象，class本身也是对象，int是对象，str是对象，dict是对象...。所以，我很好奇，python是怎样实现这些对象的？带着这份好奇，我决定去看看python的源码，毕竟源码才是满足自己好奇心最直接的方法。

在object.h文件中，定义了两种数据结构PyObject和PyVarObject，代码如下：

1 #define PyObject_HEAD 2 Py_ssize_t ob_refcnt; 3 struct _typeobject *ob_type; 4 5 #define PyObject_VAR_HEAD 6 PyObject_HEAD 7 Py_ssize_t ob_size; 8 9 typedef struct _object {10 PyObject_HEAD11 } PyObject;12 13 typedef struct {14 PyObject_VAR_HEAD15 } PyVarObject;

这两种数据结构分别对应python的两种对象：固定长度对象和可变长度对象。python中的所有对象都属于这两种对象中的一种，如int，float是固定长度对象，list，str，dict是可变长度对象。从上面两种对象数据结构定义来看，可变长度对象和固定长度对象的头都是PyObject结构体，也就是说python中所有对象的开头都包含这个结构体，并且可以用PyObject *指针来访问任何对象，这种访问对象的方法在python的源码中随处可见。PyObject结构体包含两个成员，ob_refcnt和ob_type指针。ob_refcnt用来表示对象被引用的次数，当ob_refcnt == 0时，这个对象会被立即销毁；ob_type指针指向了一个_typeobject类型的结构体，表示对象所属的类型，也就是生成该对象的类型，这其实很类似于面向对象中类与实例的关系，PyObject是某个类的实例，ob_type表示这个类。但与面向对象不同的是，ob_type本身也是个对象，我们来看下_typeobject的定义：

1 typedef struct _typeobject { 2 PyObject_VAR_HEAD 3 const char *tp_name; /*类型名 */ 4 Py_ssize_t tp_basicsize, tp_itemsize; /* 实例化对象的大小 */ 5 6 /* 标准方法 */ 7 8 destructor tp_dealloc; 9 printfunc tp_print;10 getattrfunc tp_getattr;11 setattrfunc tp_setattr;12 cmpfunc tp_compare;13 reprfunc tp_repr;14 15 /* 标准类（数值类，列表类，dict类）方法*/16 17 PyNumberMethods *tp_as_number;18 PySequenceMethods *tp_as_sequence;19 PyMappingMethods *tp_as_mapping;20 21 /* 其它标准方法*/22 23 hashfunc tp_hash;24 ternaryfunc tp_call;25 reprfunc tp_str;26 getattrofunc tp_getattro;27 setattrofunc tp_setattro;28 ...
29 } PyTypeObject;

从上面定义来看，_typeobject的开头也包含了PyObject结构体，所以它也是一个对象，既然它也是一个对象，那么按照面向对象的理解，它又是谁来生成的呢？答案是所有PyTypeObject对象都是通过PyType_Type来生成的，包括PyType_Type本身，因为PyType_Type也是PyTypeObject对象，有点绕。PyType_Type的定义是通过将PyType_Type声明为全局静态变量实现的，具体如下：

1 PyTypeObject PyType_Type = { 2 PyVarObject_HEAD_INIT(&PyType_Type, 0) 3 "type", /* tp_name */ 4 sizeof(PyHeapTypeObject), /* tp_basicsize */ 5 sizeof(PyMemberDef), /* tp_itemsize */ 6 (destructor)type_dealloc, /* tp_dealloc */ 7 0, /* tp_print */ 8 0, /* tp_getattr */ 9 0, /* tp_setattr */10 0, /* tp_compare */11 (reprfunc)type_repr, /* tp_repr */12 0, /* tp_as_number */13 0, /* tp_as_sequence */14 0, /* tp_as_mapping */15 (hashfunc)_Py_HashPointer, /* tp_hash */16 (ternaryfunc)type_call, /* tp_call */17 0, /* tp_str */18 (getattrofunc)type_getattro, /* tp_getattro */19 (setattrofunc)type_setattro, /* tp_setattro */20 0, /* tp_as_buffer */21 ...22 }

从PyType_Type定义来看，ob_type被初始化为它自己的地址，所以PyType_Type的类型就是自己。从python源码实现来看，所有PyTypeObject的ob_type都会指向PyType_Type对象，所以PyType_Type是所有类型的类型，称之为元类。python中定义了很多内建的类型对象，如PyInt_Type （int类型），PyStr_Type （str类型），PyDict_Type（dict类型） 类型对象，下面看下PyInt_Type类型的定义：

1 PyTypeObject PyInt_Type = { 2 PyVarObject_HEAD_INIT(&PyType_Type, 0) 3 "int", 4 sizeof(PyIntObject), 5 0, 6 (destructor)int_dealloc, /* tp_dealloc */ 7 (printfunc)int_print, /* tp_print */ 8 0, /* tp_getattr */ 9 0, /* tp_setattr */10 (cmpfunc)int_compare, /* tp_compare */11 (reprfunc)int_to_decimal_string, /* tp_repr */12 &int_as_number, /* tp_as_number */13 0, /* tp_as_sequence */14 0, /* tp_as_mapping */15 (hashfunc)int_hash, /* tp_hash */16 0, /* tp_call */17 ...18 };

从PyInt_Type定义来看，它主要包含了int数据类型相关的方法。PyInt_Type类型对象的初始化和PyType_Type类型类似，PyInt_Type类型的定义也是通过全局静态变量的方式实现的，除了PyInt_Type了下，所有python内建类型都是以这种方式定义的。这些类型产生的对象都会共享这些类型对象，包括这些类型定义的方法。

在python中，怎样查看对象的类型呢？有两种方法，一种是直接type：

1 >>> x = 12 >>> type(x)3 <type 'int'>

另一种是通过对象的__class__属性：

1 >>> x = 12 >>> type(x)3 <type 'int'>4 >>> x.__class__5 <type 'int'>

现在来看看int，str，dict这些类型的类型：1 <type 'int'>2 >>> type(int)3 <type 'type'>4 >>> type(str)5 <type 'type'>6 >>> type(dict)7 <type 'type'>8 >>> type(type)9 <type 'type'>从这个输出来看，int，str，dict这些类型的类型都是type，这也印证了前面说的，所有类型都是通过元类type生成的。

B. Python中类定义的问题

A1:参数self代表实例本身，例如： A=FooClass(),那么self就代表A,类函数中，self是必需的
A2:__class__获得已知对象的类,任何对象都有这个属性，__name__取得类名

A3:version是类成员变量，实例化后是实例变量，类函数获得实例变量需要带上实例本身，这个其实我也很难解释得很透彻，可以大概讲一下

version = 0.1 这里在实例化之前就已经生成了
而__init__(self,nm='Louis wu'):这里的nm变量是在实例化的时候生成的

在类方法中访问version和nm的方式是一样的,self.version和self.nm
但是version在类没有实例化的情况下也是可以访问的，因为它在实例化之前就已经声明了
你可以尝试

print FooClass.version 是可以得到version的值的
但是FooClass.nm是不可以的，必须是实例化之后才生成这个变量,FooClass().nm就可以访问到了

C. python四种基本数据类型

python是相当高级的语言，基本数据类型就很多，不过参考其他语言的，一定要四个的话：
1、整形 int
定义：age=10 #age=int(10)
用于标识：年龄，等级，身份证号，qq号，个数
2、浮点型 float
定义：salary=3.1 #salary=float(3.1)
用于标识：工资，身高，体重

3、字符窜 string
#在python中，加了引号的字符就是字符串类型，python并没有字符类型。
定义：name='egon' #name=str('egon')
用于标识：描述性的内容，如姓名，性别，国籍，种族

4、布尔 bool

D. python 类定义

self，作用是绑定，表示对类的实例化对象的绑定。比如实例化你这的Node类，n=Node()，如果方法traverse括号内不加self，当n.traverse()在Python执行则会变成n=traverse(n)，然后就会报错。所以在Python里必须加self绑定。
你也可以用其他的，比如其他语言里用this，但都得有这么个参数来占位作为绑定。

[]，表示列表的特征符。

那么这里的[self]即是让实例化对象n经过traverse得到的结果或者表达式后再将其转为列表。

比如整形数1，2。当我们用中括号把其包围，[1，2]，那么其就成了列表。就这么回事。

还可以这样：int（self），tuple（self）等的。

其实很简单，别看到self就被唬住了。

我建议还是多看看面相对象编程那一快

E. python定义数据类型

python定义数据的时候，不指定具体类型,你指定哪个类型的数据给变量，这个变量在指定后就是哪种数据，非常灵活；这点不像其他编程软件，比如C,C++,java.
比如：
a = 10
b =10.0
c="I love python"
d = True
e = 1+2j
print(a)
type(a)
print(b)
type(b)
print(c)
type(c)
print(d)
type(d)
print(e)
type(e)
****************
以下是执行结果
>>> a = 10
>>>
>>> b =10.0
>>>
>>> c="I love python"
>>>
>>> d = True
>>>
>>> e = 1+2j
>>>
>>> print(a)
10
>>>
>>> type(a)
<class 'int'>
>>>
>>> print(b)
10.0
>>>
>>> type(b)
<class 'float'>
>>>
>>> print(c)
I love python
>>>
>>> type(c)
<class 'str'>
>>>
>>> print(d)
True
>>>
>>> type(d)
<class 'bool'>
>>>
>>> print(e)
(1+2j)
>>>
>>> type(e)
<class 'complex'>
>>>
---------------
代码说明：
<class 'int'> 说明a是整型变量
<class 'float'> 说明b是浮点类型，也就是我们数学上说的带有小数点的数
<class 'str'> 说明c是字符串类型的数据
<class 'Boolen') 说明d是布尔类型的数据
<class 'complex') 说明e是复数类型的数据

F. python中如何定义int类型

标准数据类型

Python3 中有六个标准的数据类型：

Number（数字）

String（字符串）

List（列表）

Tuple（元组）

Set（集合）

Dictionary（字典）

Python3 的六个标准数据类型中：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

Python int有多种数字类型：整型int、长整型、布尔型bool、浮点数float、复数complex，先期在基础python学习过程中只要了解整型

和布尔型就可以了。

整型int的创建、声明

创建一个新整型变量和给变量赋值是相同的过程

a = 123 或 b = -123 等号左边是变量名，右边是要赋的值，就是这么简单。

整型的特点

既然是整型自然赋值时候的数据要是整数才行，整数简单理解为（正整数和负整数）。

Python学习网，大量免费的学习资源，欢迎学习！

G. python类的定义与使用是什么

类Class：用来描述具体相同的属性和方法的对象的集合。定义了该集合中每个对象所共有的属性和方法。对象是类的示例。

类定义完成时（正常退出），就创建了一个 类对象。基本上它是对类定义创建的命名空间进行了一个包装；我们在下一节进一步学习类对象的知识。原始的局部作用域（类定义引入之前生效的那个）得到恢复，类对象在这里绑定到类定义头部的类名（例子中是 ClassName ）。

基本语法

Python的设计目标之一是让代码具备高度的可阅读性。它设计时尽量使用其它语言经常使用的标点符号和英文单字，让代码看起来整洁美观。它不像其他的静态语言如C、Pascal那样需要重复书写声明语句，也不像它们的语法那样经常有特殊情况和意外。

以上内容参考：网络-Python

H. python 类的定义

Python编程中类定义，代码如下：

class<类名>:
<语句>

定义类的专有方法：

__init__构造函数，在生成对象时调用
__del__析构函数，释放对象时使用
__repr__打印，转换
__setitem__按照索引赋值
__getitem__按照索引获取值
__len__获得长度
__cmp__比较运算
__call__函数调用
__add__加运算
__sub__减运算
__mul__乘运算
__div__除运算
__mod__求余运算
__pow__称方

代码如下：

#类定义
classpeople:
#定义基本属性
name=''
age=0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight=0
#定义构造方法
def__init__(self,n,a,w):
self.name=n
self.age=a
self.__weight=w
defspeak(self):
print("%sisspeaking:Iam%dyearsold"%(self.name,self.age))

p=people('tom',10,30)
p.speak()

I. Python有哪些种类

Python有哪些种类？

1、数值型（Numbers）

2、布尔型（Booleans）

3、字符串（String）

4、Python容器

要快速学会Python，谨记‘3个’‘4类’‘5大’‘6种’这四个数字就可以了。

三个基本概念

1. 结构化（函数、模块、包）

2. 面向对象（类及派生类、重载）

3. 虚拟环境（版本管理、环境隔离）

四类基本操作

1. 数据操作（各种数据类型的操作）

2. 文件操作（文件打开读写关闭等操作）

3. 模块操作（导入使用、模块查寻等操作）

4.并发操作（进程与线程、锁/信号号/安全队列等）

五大基本语句（5）

1. 赋值语句（变量、对象、赋值运算符）

2. 输入输出语句（print, input函数）

3. 条件判断语句（if-elif-else语句）

4. 循环语句(遍历循环for-in-else、条件循环while-else、break/continue)

5. 异常处理语句(try-except-else-finally)

六种数据类型（6）

1. 数字类型（int,bool,float,complex）

2. 字符串（str）

3. 列表（list）

4. 元组（tuple）

5. 字典（dict）

6. 集合（set）

如果你能够把上面的几个要点都掌握了，那么就算是真正地入门了。

J. Python中类的定义规是什么

类的概念：

类 Class: 用来描述具体相同的属性和方法的对象的集合。定义了该集合中每个对象所共有的属性和方法。对象是类的示例。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

实例变量：定义在方法中的变量，只作用于当前实例的类。

数据成员：类变量或者实例变量用于处理类及其实例对象的相关数据。

方法：类中定义的函数。在类内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

构造函数：即__init()__，特殊的方法，在对象创建的时候被自动调用。

析构函数：即__del()__，特殊的方法，在对象被销毁时被自动调用。

实例化：创建一个类的实例，类的具体对象。就是将创建的类赋值给另一个变量。理解为赋值即可，a = class()，这个过程，就叫做实例化

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟”是一个（is-a）”关系（例图，Dog是一个Animal）。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其 进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

————————————————

原文链接：https://blog.csdn.net/f156207495/article/details/81166252

网页链接