python数据和变量类型_python 数据类型和变量初识

int (整数)

Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。

float (浮点数)

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的(除法难道也是精确的？是的！)，而浮点数运算则可能会有四舍五入的误差。

2、布尔值

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值(请注意大小写)，也可以通过布尔运算计算出来：

>>>True

True>>>False

False>>> 3 > 2True>>> 3 > 5False

布尔值可以用and、or和not运算。

and运算是与运算，只有所有都为True，and运算结果才是True：

>>>True and True

True>>>True and False

False>>>False and False

False>>> 5 > 3 and 3 > 1True

or运算是或运算，只要其中有一个为True，or运算结果就是True：

>>>True or True

True>>>True or False

True>>>False or False

False>>> 5 > 3 or 1 > 3True

not运算是非运算，它是一个单目运算符，把True变成False，False变成True：

>>>not True

False>>>not False

True>>> not 1 > 2True

3、空值

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

4、字符串(str)

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'

万恶的字符串拼接：

python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间。

字符串格式化输出

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

如下实例：

#!/usr/bin/python

print("My name is %s and weight is %d kg!" % ('Zara', 21))

以上实例输出结果：

My nameis Zara and weight is 21 kg!

PS:  %s是格式化字符串; %d是格式化整数; %f是格式化 浮点数.

字符串常用功能：

移除空白

分割

长度

索引

切片

5.列表(list)

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示

list1 = ['physics', 'chemistry', 1997, 2000];

list2= [1, 2, 3, 4, 5];

list3= ["a", "b", "c", "d"];

与字符串的索引一样，列表索引从0开始.

基本操作：

索引

切片

追加

删除

长度

切片

循环

包含

每个列表都具备如下功能：

List操作包含以下函数:

cmp(list1, list2)： 比较两个列表的元素,两个元素相同返回0，前大后小返回1，前小后大返回-1len(list)： 列表元素个数

max(list)： 返回列表元素最大值

min(list)： 返回列表元素最小值

list('var')： 将元素转换为列表

del L[1] 删除指定下标的元素

del L[1:3] 删除指定下标范围的元素

List操作包含以下方法:

L.append('var') 　　　　　　 　　append方法用于在列表的尾部追加元素，参数'var'是插入元素的值

L.insert(index,'var') 　　　　　　用于将对象插入到列表中，俩个参数，第一个是索引位置，第二个插入的元素对象.

L.pop() 　　　　　　　　　　 　　　　返回列表最后一个元素，并从List中删除.

L.pop(index) 　　　　　　　　　　　　　　返回列表索引的元素，并删除.

L.count(var) 　　　　　　　 　　　　该元素在列表中出现的个数

L.index('var') 　　　　　　　 　　　　取出元素的位置(下标)，无则抛出异常.

L.remove('var') 　　　　　　 　　remove方法用于从列表中移除第一次的值(值如果有重复则删除第一个)

L.sort() 　　　　　　　　　　　　　　排序

L.reverse() 　　　　　　　　　　　　 　　倒序

L.extend(list1) 　　　　　　 　　　　　　extend方法用于将两个列表合并，将list1列表的值添加到L列表的后面。

L.copy() 浅拷贝，只独立copy第一层，如果列表中嵌套列表修改后也会修改.

Python列表脚本操作符:

List 中 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

Python列表截取:

L = ['spam', 'Spam', 'SPAM!','xusandu']

操作实例：

#增加元素

>>> ShoppingList = ['car','clothers','iphone','apple'] #定义列表

>>> ShoppingList.append('xiaomi') #向列表中插入'xiaomi'字符串

>>> print(ShoppingList) #查看列表

['car', 'clothers', 'iphone', 'apple', 'xiaomi']>>> ShoppingList.insert(0,'smoke') #在列表下标为零处(即列表第一个元素)，插入'smoke'元素

>>> print(ShoppingList)

['smoke', 'car', 'clothers', 'iphone', 'apple', 'xiaomi']#删除

>>> ShoppingList.remove('iphone') #从列表中移除'iphone'元素

>>> print(ShoppingList)

['smoke', 'car', 'clothers', 'apple', 'xiaomi']>>> ShoppingList.pop() #如果不指定下标默认从List中删除掉最后一个元素.ShoppingList.pop(1)表示删除下标为1的元素.

'xiaomi'

>>> print(ShoppingList)

['smoke', 'car', 'clothers', 'apple']>>>

>>> del ShoppingList[0] #使用del 函数删除List中下标为0的元素(此处下标为0表示的是smoke)

>>> print(ShoppingList)

['car', 'clothers', 'apple']#改

>>> ShoppingList[0] = 'bus' #将下标为0的元素(即‘car’字符)替换为‘bus’

>>> print(ShoppingList)

['bus', 'clothers', 'apple']#查询

>>> ShoppingList[0] #查看下标为零的元素，即第一个元素

'bus'

>>> ShoppingList[-1] #查看下标为-1的元素，即倒数第一个元素

'apple'

>>> ShoppingList[1:] #查看下标为1以后所有的元素

['clothers', 'apple']>>> ShoppingList[:-1] #查看下标为-1之前的所有元素

['bus', 'clothers']>>>

>>> 'car' in ShoppingList #List列表中查找'car'元素，如果存在则返回Ture

True>>>

>>> ShoppingList.index('rain') #使用index方法查找rain的下标值

>>>

#统计

>>> print(ShoppingList)

['bus', 'clothers', 'apple', 'rain', 'car']>>> ShoppingList.count('car') #统计列表中元素'car'的个数

>>>

#排序

>>> ShoppingList.sort() #对元素按第一个字母顺序排序

>>> print(ShoppingList)

['apple', 'bus', 'car', 'clothers', 'rain']>>>

>>> ShoppingList.reverse() #倒序

>>> print(ShoppingList)

['rain', 'clothers', 'car', 'bus', 'apple']>>>

#合并列表

>>> li = [1,2,3,4]>>> ShoppingList.extend(li) #将li列表中的元素添加到ShoppingList列表中

>>> print(ShoppingList)

['rain', 'clothers', 'car', 'bus', 'apple', 1, 2, 3, 4]>>>

#copy 浅copy,只独立拷贝第一层.

ShoppingList= ['car','clothers','iphone','bus']

li=ShoppingList.copy()print(ShoppingList)print(li)

ShoppingList[1] = "apple"

print(ShoppingList)print(li)#在列表中嵌套一个列表

ShoppingList = ['car','clothers',['a','b','c'],'iphone','bus']

lis=ShoppingList.copy()

ShoppingList[1] = "milk"ShoppingList[2][0] = "A"

print(ShoppingList)print(lis)----执行结果-----------------------['car', 'clothers', 'iphone', 'bus']

['car', 'clothers', 'iphone', 'bus']

['car', 'apple', 'iphone', 'bus']

['car', 'clothers', 'iphone', 'bus']

['car', 'milk', ['A', 'b', 'c'], 'iphone', 'bus']

['car', 'clothers', ['A', 'b', 'c'], 'iphone', 'bus']

使用列表实现购物车功能

#!/usr/bin/env python#coding:utf-8

'''脚本思路：

1.判断用户输入类型,

2.循环出商品和下标的对应值

3.判断用户商品编号输入值

4.商品价格和用户输入金额比较,如果商品价格低于用户余额，将商品加入购物车并减去商品价格.'''product_list=[

('Iphone',5800),

('Mac Pro',9800),

('Bike',800),

('Watch',10600),

('Coffee',31),

('Python',120),

]

shoping_list=[]

salary= input("请输入你的工资:")#如果输入的是数字返回True，如果不全是数字则返回flase.

ifsalary.isdigit():

salary=int(salary)whileTrue:for index,item in enumerate(product_list,start=0):print(index,item)

user_choice= input("请输入你要买商品的编号>>>:")ifuser_choice.isdigit():

user_choice=int(user_choice)if user_choice < len(product_list) and user_choice >=0:

p_item= product_list[user_choice] #通过商品下标取出商品对应元组

#print(p_item[1])

#通过商品价格和输入金额对比，如果买得起则进行后续操作

if p_item[1] <=salary:

shoping_list.append(p_item)#购买商品后的用户余额

salary -= p_item[1]print("你买的商品是 %s 你的剩余金额为 %s" %(shoping_list,salary))else:print("你的余额剩余 %s ,买不起该商品." %(salary))else:print("你输入的商品编号%s不存在." %(user_choice))elif user_choice == 'q' or user_choice == 'exit':print('''购买的商品列表如下：''')for i inshoping_list:print(i)print("你目前的余额为 %s" %(salary))

exit()else:print("编号必须为数字")else:print("输入工资必须为数字")

购物车代码

6.元组 (不可变列表)

不可变序列-----元组 tuple

元组通过圆括号中用逗号分隔的项目定义,不可以添加和删除元组.

创建元组：

ages = (11, 22, 33, 44, 55)

或

ages= tuple((11, 22, 33, 44, 55))

每个元组都具备如下功能：connt,index

>>> name_tuple = ('a','b','c','a','b')>>>type(name_tuple)

>>> name_tuple.count('a') //统计a出现次数2

>>> name_tuple.index('b') //获取b元素下标位置.

1

7.dict(字典)

字典是Python语言中唯一的映射类型。

映射类型对象里哈希值(键，key)和指向的对象(值，value)是一对多的的关系，通常被认为是可变的哈希表。

字典对象是可变的，它是一个容器类型，能存储任意个数的Python对象，其中也可包括其他容器类型。

字典的特性：

dict是无序的

key必须是唯一的

字典没有下标.通过key检索

创建字典：

person = {"name": "saneri", 'age': 20}

或

person = dict({"name": "saneri", 'age': 20})

技巧：

字典中包含列表或字典

var1= {"ZhangSan" : ['23','IT'],"Lisi" : ['22','dota']}

var2= {"Wangwu" : {"age" : 23,"job":"IT"},"Song" : {"age":22,"job":"dota"}}

常用操作：

索引

新增

删除

键、值、键值对

循环

长度

python字典实例操作

#增加

>>> info = { "zhangsan" : 20,"Lisi" : 30,"Wangwu" : 40}>>> info['Zhaoliu'] = 60

>>> print(info)

{'zhangsan': 20, 'Lisi': 30, 'Wangwu': 40, 'Zhaoliu': 60}#修改#如果key存在则修改值，不存在则添加

>>> info['Zhaoliu'] = 80

>>> print(info)

{'zhangsan': 20, 'Lisi': 30, 'Wangwu': 40, 'Zhaoliu': 80}#删除

第一种方法，标准删除>>> print(info)

{'zhangsan': 20, 'Lisi': 30, 'Wangwu': 40, 'Zhaoliu': 80}>>> info.pop("Zhaoliu")80

>>> print(info)

{'zhangsan': 20, 'Lisi': 30, 'Wangwu': 40}

第二种方法：>>> del info["Zhaoliu"]>>> print(info)

{'zhangsan': 20, 'Lisi': 30, 'Wangwu': 40}

第三种，随机删除>>>info.popitem()

('Zhaoliu', 80)>>> print(info)

{'zhangsan': 20, 'Lisi': 30, 'Wangwu': 40}#查找

>>> print(info)

{'zhangsan': 20, 'Lisi': 30, 'Wangwu': 40, 'Zhaoliu': 80}>>> info['zhangsan'] #如果key存在就返回结果

20

>>> info['saneri'] #如果key不存在，dict就会报错：

Traceback (most recent call last):

File"", line 1, in KeyError:'saneri'要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：>>> 'zhangsan' ininfo

True

二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：>>> info.get('saneri')>>> info.get('saneri',-1)-1注意：返回None的时候Python的交互式命令行不显示结果。#info.keys()方法

>>>info

{'zhangsan': 20, 'Lisi': 30, 'Wangwu': 40, 'Zhaoliu': 80}>>>info.keys()

dict_keys(['zhangsan', 'Lisi', 'Wangwu', 'Zhaoliu'])#info.values()方法

>>>info.values()

dict_values([20, 30, 40, 80])#info.items()方法

>>>info.items()

dict_items([('zhangsan', 20), ('Lisi', 30), ('Wangwu', 40), ('Zhaoliu', 80)])#info.setdefault()方法

setdefault() 函数和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值>>> info.setdefault('saneri','100')'100'

>>>info

{'zhangsan': 20, 'Lisi': 30, 'Wangwu': 40, 'Zhaoliu': 80, 'saneri': '100'}>>> info.setdefault('adny')>>>info

{'zhangsan': 20, 'Lisi': 30, 'Wangwu': 40, 'Zhaoliu': 80, 'saneri': '100', 'adny': None}#info.update()方法

>>>info

{'zhangsan': 20, 'Lisi': 30, 'Wangwu': 40, 'Zhaoliu': 80, 'saneri': '100', 'adny': None}>>> dict = {1:2,3:4,'tom':'IT'}>>>info.update(dict)>>>info

{'zhangsan': 20, 'Lisi': 30, 'Wangwu': 40, 'Zhaoliu': 80, 'saneri': '100', 'adny': None, 1: 2, 3: 4, 'tom': 'IT'}

循环dict的方法

#!/usr/bin/env python#coding:utf-8

info={"zhangsan" : 20,"Lisi" : 30,"Wangwu" : 40}#1.建议使用

for i ininfo:print(i,info[i])print('---------------------------')#2.会先把dict转成list,数据里大时莫用

for k,v ininfo.items():print(k,v)-----------执行结果------------zhangsan20Lisi30Wangwu40

---------------------------zhangsan20Lisi30Wangwu40

三级菜单

#!/usr/bin/env python#coding:utf-8

city_list={"北京": {"海淀区": {"上地" : ["百度大厦"],"海淀黄庄" : ["互联网金融大厦"],"中关村" : ["海龙大厦"],

},"朝阳区": {"朝阳门" : ["丰联大厦"],"东直门" : ["银泰大厦"],"望京" : ["望京soho"],

},"昌平区": {"回龙观" : ["华联超市"],"龙泽" : ["美廉美超市"],"霍营" : ["霍营超市"],

},

},"陕西省": {"西安市": {"长安区" : [1],"碑林区" : [2],"雁塔区" : [3],"莲湖区" : [4],

},"咸阳市": {"秦都区": [0],"渭城区": [0],"西咸新区": [0],

},

},

}whileTrue:for i in city_list: #打印第一层

print(i)#北京、陕西省

choice = input("请输入城市名>>>>>:").strip()if choice in city_list: #如果输入城市在字典中,则执行如下操作

whileTrue:for m in city_list[choice]: #打印第二层

print(m)

choice2= input("请选择市区>>>>:").strip()if choice2 incity_list[choice]:whileTrue:for k in city_list[choice][choice2]: #打印第三层

print(k)

choice3= input("请选择区县>>>>>>>:").strip()if choice3 incity_list[choice][choice2]:for v in city_list[choice][choice2][choice3]: #打印第四层

print(v)

choice4= input("已经是最后一级,按b键返回>>>>:")if choice4 == "b":pass

if choice3 == "b":break

if choice2 == "b":break

if choice == "b":

exit()

三级菜单练习

#!/usr/bin/env python#coding:utf-8

city_list={"北京": {"海淀区": {"上地" : ["百度大厦"],"海淀黄庄" : ["互联网金融大厦"],"中关村" : ["海龙大厦"],

},"朝阳区": {"朝阳门" : ["丰联大厦"],"东直门" : ["银泰大厦"],"望京" : ["望京soho"],

},"昌平区": {"回龙观" : ["华联超市"],"龙泽" : ["美廉美超市"],"霍营" : ["霍营超市"],

},

},"陕西省": {"西安市": {"长安区" : [1],"碑林区" : [2],"雁塔区" : [3],"莲湖区" : [4],

},"咸阳市": {"秦都区": [0],"渭城区": [0],"西咸新区": [0],

},

},

}

exit_flag=Falsewhile notexit_flag:for i incity_list:print(i)

choice= input("请输入省市>>>>>>:").strip()if choice incity_list:while notexit_flag:for m incity_list[choice]:print(m)

choice2= input("请输入市区>>>>:").strip()if choice2 incity_list[choice]:while notexit_flag:for k incity_list[choice][choice2]:print(k)

choice3= input("请输入区县>>>>:").strip()if choice3 incity_list[choice][choice2]:while notexit_flag:for v incity_list[choice][choice2][choice3]:print(v)

choice4= input("最后一层,返回请按b键,退出请按q>>>:")if choice4 == "b":break

elif choice4 == "q":

exit_flag=Trueif choice3 == "b":break

elif choice3 == "q":

exit_flag=Trueif choice2 == "b":break

elif choice2 == "q":

exit_flag=Trueif choice == "b":break

elif choice == "q":

exit_flag= True

标志位三级菜单

8.set集合

集合(set)是一个无序不重复元素的序列。

它的主要作用如下：

去重，把一个列表变成集合，就自动去重了

关系测试，测试两组数据之前的交集、差集、并集等关系

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

1.可以使用大括号 { }

s={value1,value2,...}2.或提供一个list作为输入集合

s= set([value1,value2,...])3.或者 set() 函数创建集合set(value)

1. set成员测试

>>>student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}>>>print(student) # 输出集合，重复的元素被自动去掉

{'Mary', 'Tom', 'Jack', 'Rose', 'Jim'}

# 成员测试>>> if('Rose' instudent) :

... print('Rose 在集合中')

...else:

... print('Rose 不在集合中')

...

Rose 在集合中>>>

2.set进行集合运算

>>> s = set([3,5,9,10])>>> t = set(['a','b','c',1,2,3])>>> s -t # 求差集(项在s中，但不在t中)

{9, 10, 5}>>> s |t # s 和 t的并集

{1, 2, 3, 'b', 5, 'c', 9, 10, 'a'}>>> s &t # 求s 和 t的交集

{3}>>> s ^t #对称差集(项在s或t中，但不会同时出现在二者中)

{1, 2, 'b', 'c', 'a', 5, 9, 10}

3.通过set方法函数对集合进行操作

>>> s = set([3,5,9,10])>>> t = set(['a','b','c',1,2,3])#add(增加元素)

>>> t.add('x')>>>t

{1, 2, 3, 'b', 'c', 'x', 'a'}#remove()可以删除一项：

>>> t.remove('a')>>>t

{1, 2, 3, 'b', 'c', 'x'}>>>len(t)6

#测试 x 是否是 t 的成员

>>> 'x' int

True#测试 x 是否不是 t 的成员

>>> 'x' not int

False#issubset(判断子集)

>>>s.issubset(t)

False#issuperset(判断父集)

>>>s.issuperset(t)

False#返回一个新的 set 包含 s 和 t 中的每一个元素

>>>s.union(t)

{1, 2, 3, 'b', 5, 'c', 9, 10, 'x'}#返回一个新的 set 包含 s 和 t 中的公共元素

>>>s.intersection(t)

{3}

#返回一个新的 set 包含 s 中有但是 t 中没有的元素>>>s.difference(t)

{9, 10, 5}

#返回一个新的 set 包含 s 和 t 中不重复的元素>>>s.symmetric_difference(t)

{'x', 1, 2, 'b', 'c', 5, 9, 10}#在s中添加多项

>>> s.update([10,37,42])>>>s

{3, 37, 5, 9, 10, 42}>>>

变量

变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。

变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头

在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，例如：

a = 123# a是整数

print(a)

a= 'ABC'# a变为字符串

print(a)

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如Java是静态语言，赋值语句如下(// 表示注释)：

int a = 123; //a是整数类型变量

a = "ABC"; //错误：不能把字符串赋给整型变量

和静态语言相比，动态语言更灵活，就是这个原因。

请不要把赋值语句的等号等同于数学的等号。比如下面的代码：

x = 10x= x + 2

如果从数学上理解x = x + 2那无论如何是不成立的，在程序中，赋值语句先计算右侧的表达式x + 2，得到结果12，再赋给变量x。由于x之前的值是10，重新赋值后，x的值变成12。

理解变量在计算机内存中的表示也非常重要。当我们写：

a = 'ABC'

时，Python解释器干了两件事情：

在内存中创建了一个'ABC'的字符串；

在内存中创建了一个名为a的变量，并把它指向'ABC'。

也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据，例如下面的代码：

a = 'ABC'b=a

a= 'XYZ'print(b)

最后一行打印出变量b的内容到底是'ABC'呢还是'XYZ'？如果从数学意义上理解，就会错误地得出b和a相同，也应该是'XYZ'，但实际上b的值是'ABC'，让我们一行一行地执行代码，就可以看到到底发生了什么事：

执行a = 'ABC'，解释器创建了字符串'ABC'和变量a，并把a指向'ABC'：

执行b = a，解释器创建了变量b，并把b指向a指向的字符串'ABC'：

执行a = 'XYZ'，解释器创建了字符串'XYZ'，并把a的指向改为'XYZ'，但b并没有更改：

所以，最后打印变量b的结果自然是'ABC'了。

在Python中，有两种除法，一种除法是/,/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：

除法是//，称为地板除，两个整数的除法仍然是整数：

Python还提供一个余数运算，可以得到两个整数相除的余数：

>>> 9 / 3

3.0

>>> 9 //3

3

>>> 9 % 3

0

>>> 10 % 3

1

字符串和编码

在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。