Python教程：变量类型

Python 变量类型

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

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

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

变量赋值

Python中的变量不需要声明，变量的赋值操作既是变量声明和定义的过程。

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

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

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

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

name='zk'
sex='man'
age=29
job="none"
count=1000
mile=1000.1
bool=True
print(name+" "+sex+" "+job+" ")
print(bool)
print(count)
print(mile)

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

zk man none 
True
1000
1000.1

多个变量赋值

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

a=b=c=1
print(a)
print(b)
print(c)

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

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

d,e,f=5,"str",4
print(d)
print(e)
print(f)

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

5
str
4

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

标准数据类型

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

例如，person.s年龄作为一个数值存储和他或她的地址是字母数字字符存储。

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（复数）

一些数值类型的实例

int	long	float	complex
10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j
-786	0122L	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEl	32.3+e18	.876j
-0490	535633629843L	-90.	-.6545+0J
-0x260	-052318172735L	-32.54e100	3e+26J
0x69	-4721885298529L	70.2-E12	4.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。

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

str = 'Hello World!'print(str) # 输出完整字符串
print(str\[0\]) # 输出字符串中的第一个字符
print(str\[2:5\]) # 输出字符串中第三个至第五个之间的字符串
print(str\[2:\]) # 输出从第三个字符开始的字符串
print(str \* 2) # 输出字符串两次
print(str + "TEST") # 输出连接的字符串

输出结果如下：

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

字符串split函数

txt='www.baidu.com'
print(txt.split('.'))
print(txt.split('.')\[1\])

输出结果如下：

取结尾为.jpg的文件名

img=\['aa.png','bb.jpg','cc.jpg'\]
result=\[\]
for file in img:if file.split('.')\[1\]=='jpg':result.append(file)
print(result)

输出结果如下：

例题：

在网页列表中选择网页出现次数最多的网址，列表如下：

'http://www.baidu.com/index.html',  
'http://www.baidu.com/1.html',  
'http://post.baidu.com/index.html',  
'http://mp3.baidu.com/index.html',  
'http://www.baidu.com/3.html',  
'http://post.baidu.com/2.html'

raw = \['http://www.baidu.com/index.html','http://www.baidu.com/1.html','http://post.baidu.com/index.html','http://mp3.baidu.com/index.html','http://www.baidu.com/3.html','http://post.baidu.com/2.html',
\]result=\[\]
for single\_raw in raw:page\_domain\_afterhttp = single\_raw.split('/')\[2\]result.append(page\_domain\_afterhttp)
print(max(result))

输出结果：

字符串拼接

var1="zk"
var2="lwt"
schoolname="wanmendaxue"
pinjie=var1+var2+schoolname
word\_1="Pi等于"
word\_2=3.1415
result=word\_1+str(word\_2)
print(pinjie)
print(result)

输出结果：

zklwtwanmendaxue
Pi等于3.1415

Python占位符的三种形式

name="张焜"
age=29
height=1.79
school='中国矿业大学'
boys=100
girls=200
print(f"我叫{name},年龄{age},学校{school},身高{height},班里有男孩{boys}个,女孩{girls}个")
print("我叫%s,年龄%d,学校%s,身高%.2f,班里有男孩%d个,女孩%d个" %(name,age,school,height,boys,girls))
print("我叫{0},年龄{1},学校{2},身高{3},班里有男孩{4}个,女孩{5}个".format(name,age,school,height,boys,girls) )

Python数学函数

import math
int\_1=10
int\_2=-10
double\_1=1.45
print(abs(int\_1))           #绝对值
print(abs(int\_2))
print(min(int\_1,int\_2))     #两数取小
print(max(int\_1,int\_2))     #两数取大
print(math.floor(double\_1)) #向下取整
print(math.ceil(double\_1))  #向上取整
print(math.sqrt(int\_1))     #开根号

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)

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

1、int函数：

（1）把符合数学格式的数字型字符串转换成整数，字符串内非数字无法转换为整数
（2）把浮点数转换成整数，但是只是简单的取整，而非四舍五入，浮点数整数会消除小数部分取整

aa = int("124")    #Correct
print("aa = ", aa)  #result=124
bb = int(123.45) #correct
print("bb = ", bb) #result=123
cc = int("-123.45")  #Error,Can't Convert to int
print("cc = ",cc)
dd = int("34a")    #Error,Can't Convert to int
print("dd = ",dd)
ee = int("12.3") #Error,Can't Convert to int
print(ee)

2、float函数将整数和字符串转换成浮点数，字符串内非数字无法转换为浮点

aa = float("124")     #Correct
print("aa = ", aa)     #result = 124.0 
bb = float("123.45")  #Correct
print("bb = ", bb)     #result = 123.45
cc = float(-123.6)    #Correct
print("cc = ",cc)      #result = -123.6
dd = float("-123.34") #Correct
print("dd = ",dd)      #result = -123.34
ee = float('123v')    #Error,Can't Convert to float
print(ee)

3、str函数将数字转换成字符，字符串或整数转化为浮点数，整数后面多一位小数

aa = str(123.4)     #Correct
print aa            #result = '123.4'
bb = str(-124.a)    #SyntaxError: invalid syntax
print bb
cc = str("-123.45") #correct
print cc            #result = '-123.45'
dd = str('ddd')     #correct
print dd            #result = ddd
ee = str(-124.3)    #correct
print ee            #result = -124.3

Python整数、浮点数的多则运算----加、减、乘、除、商、取余、次幂

aa=1
bb=2
print(aa+bb)   #加法  3
print(aa-bb)   #减法   -1
print(aa/bb)   #除数   0.5
print(aa//bb)  #商   0
print(aa%bb)   #取余   1
print(bb\*\*3)   #次幂   8
print(aa+bb,aa-bb,aa/bb,aa%bb,bb\*\*3,sep="\\n")
3
-1
0.5
1
8
print(aa+bb,aa-bb,aa/bb,aa%bb,bb\*\*3,sep="\*\*\*")　　 3\*\*\*-1\*\*\*0.5\*\*\*1\*\*\*8

Python列表

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

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

列表用[ ]标识。是python最通用的复合数据类型。看这段代码就明白。

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

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

list = \[ 'abcd', 786 , 2.23, 'john', 70.2 \]
tinylist = \[123, 'john'\]print(list) # 输出完整列表
print(list\[0\]) # 输出列表的第一个元素
print(list\[1:3\]) # 输出第二个至第三个的元素 
print(list\[2:\]) # 输出从第三个开始至列表末尾的所有元素
print(tinylist \* 2) # 输出列表两次
print(list + tinylist) # 打印组合的列表

Python元字典

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

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

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

Dict\_1={'德国':'奔驰车队','英国':'迈凯伦车队','意大利':'法拉利车队'}
print(type(Dict\_1))
print(Dict\_1)
print(str(Dict\_1))
print(Dict\_1\['德国'\])     #获取键值
Dict\_1\['德国'\]='BMW'      #修改键值
print(Dict\_1\['德国'\])
Dict\_1\['中国'\]='红旗'     #增加键值
print(Dict\_1)
del Dict\_1\['英国'\]       #删除键值
print(Dict\_1)
Dict\_1.clear()           #清空列表
print(Dict\_1)

Python元组

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

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

tuple\_1=(1,'a','BMW','XFL',3)
tuple\_2=(2,'b','WMB','LFX',4)
print(tuple\_1)     #输出完整元组1
print(tuple\_2)     #输出完整元组2
print(tuple\_1\[1\])  #输出tuple\_1的第二个元素
print(tuple\_1\[2:\]) #输出tuple\_1的第三个之后的元素
print(tuple\_1\[:3\]) #输出tuple\_1的第四个之后的元素
print(tuple\_1\*2)   #输出两遍tuple\_1
print(tuple\_1+tuple\_2)   #输出tuple\_1和tuple\_2的混合元素

Python逻辑运算

所有的基础逻辑运算结果：（1）一切皆真假（2）一切皆0和1（3）一切皆True和False

运算逻辑要有可比性：（1）整数与整数相比（2）整数与浮点数相比（3）浮点数与浮点数相比（4）字符串与字符串相比

（5）字符串不可与其他类型比大小，但是可以比相等

比较运算符

a=100
b=200
print(a==b)
print(a!=b)
print(a>b)
print(a<b)
print(a>=b)
print(a<=b)

输出结果：False True False True False True

逻辑运算（或且非运算）

a=100
b=200
print(a==b and a!=b)
print(a==b or a!=b)
print(not a==b)

输出结果：False 　True 　True

and优先级大于or

成员运算

str\_1='abcd'
str\_2='efgh'
print('a' in str\_1)
print('a' in str\_2)
print('e' in str\_2)
print('e' in str\_1)
print('a' not in str\_1)
print('a' not in str\_2)
print('e' not in str\_2)
print('e' not in str\_1)

输出结果：True False True False False True False True

身份运算（即比较内存地址）

result\_1=1
result\_2=1
result\_3=2
print(id(result\_1)==id(result\_2))
print(id(result\_2)==id(result\_3))

相同的值会默认指向相同的内存地址。

bedroom\_1="枕头"
pillow\_1="枕头"
print(id(bedroom\_1),id(pillow\_1))      #140469614890320 140468288321552
print(bedroom\_1 is pillow\_1)           #False
print(bedroom\_1 is not pillow\_1)       #True

bedroom\_1="枕头"
pillow\_1=bedroom\_1
print(id(bedroom\_1),id(pillow\_1))  #140469614896176 140469614896176
print(bedroom\_1 is pillow\_1)         #True
print(bedroom\_1 is not pillow\_1)   #False

bedroom\_1="枕头"
pillow\_1="枕头"
print(id(bedroom\_1),id(pillow\_1))
print(bedroom\_1 is pillow\_1)
print(bedroom\_1==pillow\_1)

is比较符用于比较两个变量的地址，两个变量地址不相同则为False。==比较符比较的是两个变量的值，值相同则为True。