python数字类型及运算_python数据类型及运算符

第一个程序

print("hello world")

变量：变量在程序中就是一个容器。（用来装东西，去超市买东西时候推得手推车就是变量）

score=100 #定义一个变量，这个变量名字就score，它里面存储的一个数值100

high=180 #定义一个变量，变量值是180

注释：#井号为注释号 /多行注释''''''

一.基本数据类型

python（数据类型）主要有6中数据类型：

Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Dictionary（字典）、Set（集合）

其中number数字类型支持 int、float、bool、complex（复数）。

（1）numbers 数字

整型 int

a = 1

print(type(a))>>> 2 ** 100

1267650600228229401496703205376L

布尔型 boor

True False

print (1 > 2)print (1 < 2)

浮点型 float

a = 1.0

print (type(a))

复数 complex

6.23+1.5j -1.23-987j

（2）字符串 str

name="wuchuan"

print(type(name))

（3）列表（list）

列表是Python 中使用最频繁的数据类型。列表是写在方括号[ ]之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

特点：支持对列表进行修改/删除/插入元素操作，[ ]内为空或者只有单个/多个元素，都为列表。

list_1=[]

list_2= [1]

list_3= ["zhangsan","lisi","wangwu"]

list_4=['guangdong','guangxi',['shenzhen','zhuhai']]print(list_1, list_3 ,list_4)

（4）元组（tuple）

元组与列表类似，不同之处在于元组的元素不能修改；元组的元素写在小括号（）里，元素之间用逗号隔开。

注意：括号内为空时，则是一个空元组。

括号内只有一个元素时，则不为元组，由括号内元素类型定义

要想实现括号内只有一个元素的元组，则需要在该元素后面加入逗号","

tup_1=()

tup_5=("zhangsan","lisi","wangwu")

tup_2=(1)

tup_3=('ni')

tup_4=([2])print(type(tup_1))print(type(tup_5))print(type(tup_2))print(type(tup_3))print(type(tup_4))

（5）字典（dict）

字典是一个有键值对组成的数据类型；用大括号{ }来表示一个字典。字典括号内为键值对格式 如{"key1":"value1","key2":"value2"}。支持对字典进行修改/删除/插入元素操作。

创建一个空字典，直接在变量名后面加上一个花括号{ }

dic_1= {"name":"zhangsan","age":28,"sex":"boy"}

dic_2= {"name1":"zhangsan","age":{"age1":"18","age2":20},"name2":"lisi","name3":"wangwu"}print(dic_1)print (type(dic_1))

（6）集合（set）

集合是写在花括号 { } 里面或者 set() 函数创建集合；用逗号 , 分隔开。

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

a = {1,2,3}print(a)print(type(a))

d={}print(type(set(d)))

二.数据类型的转换

1，整型转换为字符串用str()函数

（int转str ）

c=123d=str(c)#通过变量赋值print(type(d))

a = 123

print(str(a))print (type(str(a)))

2.转化为整型用int()函数（str转int）

a = "123"b=int(a)print(type(a))print(type(b))

3.list() 方法用于将元组或字符串转换为列表。

（str转list）

a="123"b=list(a)print(type(a))print(type(b))

（tuple转list）

a = (1,2,3)print(list(a))print (type(list(a)))

（set转list）

a={"shenzhen","foshan","xianggan"}

b=list(a)print(type(a))print(type(b))

4. tuple() 可以将字符串，列表，字典，集合转化为元组；

（str转tuple）

a="2343"b=tuple(a)print(type(b))

（list转tuple）

a=["shenzhe","dongguang",40,23]

b=tuple(a)print(type(b))

（dict转tuple）

a={"name":"shenzhe","age":40}

b=tuple(a)print(b)#将字段转换为元组时候只保留键！

print(type(b))

（set转tuple）

a={"shenzhen","foshan","xianggan"}

b=tuple(a)print(type(b))

5．set() 可以将字列表，元组，转化为集合

（list转set）

a=[1,2,4,4]

b=set(a)#set()函数有去重功能，把重复的元素去掉

print(type(b))

（tuple转set）

a=('huawei','sanxing','apple')

b=set(a)print(type(b))

(dict 转 set)

a={"shenzhen":"nanshan","foshan":"nanhai"}

b=set(a)print(b)#取键

print(type(b))

三、运算符

1.算数运算符

（1）加（+）

注意：字符串与整数之间不能进行相加，需要通过str()或int()进行转换数据类型

整数与整数相加

a="3"b=4b=str(b)print(a+b)

浮点数与浮点数相加

"""二进制存储精度误差"""

a=3.6b=4.44

print(a+b)

整数与浮点数相加

字符串之间相加

a="hello"b="shenzhen"

print(a+b)

正数与负数相加

（2）减（-）

注意：字符串与整数和字符串之间不能进行相减

整数与整数相减

>>> 10 - 5

5

负数与负数相减

>>> -3 - -4

1

正数与负数相减

浮点数与浮点数相减

整数与浮点数相减

（3）乘（*）

注意：字符串与字符串之间不能进行相乘

整数与整数相乘

>>> 3 * 2

6

浮点数与浮点数相乘

整数与浮点数相乘

正数与负数相乘

负数与负数相乘

（4）除（/）

注意：字符串与字符串和整数之间不能进行相除

"""整数相除，结果为整数"""

python2.x 整数与整数相除>>> 6 / 3

2

"""整数相除，结果为浮点数"""

python3.x 整数与整数相除>>> 6/3

2.0

浮点数与浮点数相除

整数与浮点数相除

（5）求幂（**）

如x ** y --> 返回x的y次幂

>>> 3 ** 3

27

>>> 10 ** 2

100

（6）取模 （%）--> 返回除法的余数

>>> 5 % 3

2

"""-a % b = b - (a % b)"""

>>> -304 % 100

96

（7）整除法（//） -->向左取整

正数（正数向零取整）

>>> 9.0 // 2

4.0

负数（负数取偏小一位数）

>>> -9.0 // 2

-5.0

>>> -9 // 2

-5

注意：

1.先乘除后加减

2. 幂运算优先级最高

2.赋值运算符

（1）=等号是主要的赋值运算符

变量的使用和命名

变量名只能包含字母、数字和下划线，可以以字母或下划线打头，但是不能以数字打头

变量不能包含空格

不要以 python 中的关键字（保留字符）作为变量

变量名应简短又具有描述性

变量区分大小写

name = "Alex Li"name2=nameprint(name,name2)

name= "Jack"

print(name)

python内存回收机制如下：

变量相当于门牌号，当门牌没有了，即函数的引用都没有调用了，内存的数据就会被清除掉。

python内有个定时器，定期的会刷新，如果发现内存中数据不被引用了，就会被回收，这个就是内存的回收机制。

（2）+=　　加法赋值运算符

a += 1 --> a = a + 1

a=3a+=1

print(a)

（3）-=　　减法赋值运算符

a -= 1 --> a = a – 1

a=10a-=1a=a-1

print(a)

（4）*=　　乘法赋值运算符

a *= 1 --> a = a * 1

（5）/=　　除法赋值运算符

a /= 2 --> a = a / 2

（6）%=　　取模赋值运算符

a %= 3 --> a = a % 3

（7）**=　　幂赋值运算符

c **= a 等效于 c = c ** a

（8）//=　　取整除赋值运算符

c //= a 等效于 c = c // a

3.比较运算符（返回值为Boolean值----布尔值）

（1）==　　等于 - 比较对象是否相等

>>> "name" == "name"True>>> 1 == 1True>>> 1 == 2False

（2）!=或<>　　不等于 - 比较两个对象是否不相等

>>> 1 != 2True>>> 1 <> 1False>>> "name" != "name1"True

（3）> 大于

>>> 2 > 1True>>> 5 > 8False>>> "shenzhen">"shenzhe"True

（4）< 小于

>>> 1 < 2True>>> 3 < 2False

（5）>= 大于等于

>>> 2 >= 2True

（6）<= 小于等于

>>> 2 <= 2True

注意：字符串按位比较，两个字符串第一位字符的ascii码谁大，字符串就大，不再比较后面的；第一个字符相同就比第二个字符串，以此类推，需要注意的是空格的ascii码是32，空（null）的ascii码是0，大写字母和小写字母的ASCII不同

4.身份运算符（用于比较两个对象的存储单元--内存地址）

（1）is 　　是判断两个标识符是不是引用自一个内存地址

x is y，类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False

>>> 1 is 1True>>> 1 is 2False

（2）is not 　　是判断两个标识符是不是引用自不同对象

x is not y， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False

>>> 1 is not 1False>>> 1 is not 2True

注意：

小整数对象池：python在执行的时候，为了节约空间，帮我们创建好了小整数对象池，[-5~256]，都是固定的地址，不管你用不用，都会存在。

比如，a=5,b=5,id(a)和id(b)的地址都是小整数池中固定已经存在的地址，所以相等

但如果，a=1000,b=1000,这时会给a一个地址，也会给b一个地址，但他们都不相等。

5.逻辑运算符

（1）逻辑与(and)：两边的表达式同时为真，结果才为真。

a=10b=30

print(a==9 and b==30)

Falseprint(a==10 and b==30)

True

（2）逻辑或(or)：两边的表达式一个为真，结果就为真。一个为真，结果就为真。

a=10b=30

print(a==9 or b==30)print(a==10 or b==30)print(a==11 or b==31)

（3）逻辑非（not）：用于取反表达式，真变假，假变真

b=30

print(not b==310)print(not b==30)

逻辑运算符的优先级:从左到右：() > not > and > or

计算：1>3 or

3>2 and 1=0 and not(7>2

or

3>5)

从左到右，先计算（）里，7>2为True,则括号里为True，再看括号外面的not，则这一部分为false.

再先计算左边的and，3>2为True,则看1=0的布尔值，1=0为False,则3>2 and 1=0为False.

再计算 3>2 and 1=0 and not(7>2 or 3>5)，已知3>2 and 1=0 为False, not(7>2 or 3>5)为False，则3>2 and 1=0 and not(7>2 or

3>5)为False。

最后看1>3为False,3>2 and 1=0

and not(7>2 or 3>5)为False,则整体为False.

6.成员运算符

（1）in：判断一个值是在另一个变量中

如下：a 在 b序列中则返回True，否则返回False

a=10b=[1,2,20,10]

c=(1,2,10)print(a inb)print(a in c)

（2）not in　　判断一个值不在另一个变量中

如下：a 不在 b序列中则返回True，否则返回False

a=1b=[1,2,20,10]

c=(3,2,10)print(a not inb)print(a not in c)

结果：

False

True