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=123 d=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=4 b=str(b) print(a+b)
浮点数与浮点数相加
"""二进制存储精度误差"""
a=3.6 b=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 = name print(name,name2) name = "Jack" print(name)
python内存回收机制如下：
变量相当于门牌号，当门牌没有了，即函数的引用都没有调用了，内存的数据就会被清除掉。
python内有个定时器，定期的会刷新，如果发现内存中数据不被引用了，就会被回收，这个就是内存的回收机制。
（2）+= 加法赋值运算符
a += 1 --> a = a + 1
a=3 a +=1 print(a)
（3）-= 减法赋值运算符
a -= 1 --> a = a – 1
a=10 a -=1 a=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 == 1 True >>> 1 == 2 False
（2）!=或<> 不等于 - 比较两个对象是否不相等
>>> 1 != 2 True >>> 1 <> 1 False >>> "name" != "name1" True
（3）> 大于
>>> 2 > 1 True >>> 5 > 8 False >>> "shenzhen">"shenzhe" True
（4）< 小于
>>> 1 < 2 True >>> 3 < 2 False
（5）>= 大于等于
>>> 2 >= 2
True
（6）<= 小于等于
>>> 2 <= 2
True
注意：字符串按位比较，两个字符串第一位字符的ascii码谁大，字符串就大，不再比较后面的；第一个字符相同就比第二个字符串，以此类推，需要注意的是空格的ascii码是32，空（null）的ascii码是0，大写字母和小写字母的ASCII不同
4.身份运算符（用于比较两个对象的存储单元--内存地址）
（1）is 是判断两个标识符是不是引用自一个内存地址
x is y，类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
>>> 1 is 1 True >>> 1 is 2 False
（2）is not 是判断两个标识符是不是引用自不同对象
x is not y， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False
>>> 1 is not 1 False >>> 1 is not 2 True
注意：
小整数对象池：python在执行的时候，为了节约空间，帮我们创建好了小整数对象池，[-5~256]，都是固定的地址，不管你用不用，都会存在。
比如，a=5,b=5,id(a)和id(b)的地址都是小整数池中固定已经存在的地址，所以相等
但如果，a=1000,b=1000,这时会给a一个地址，也会给b一个地址，但他们都不相等。
5.逻辑运算符
（1）逻辑与(and)：两边的表达式同时为真，结果才为真。
a=10 b=30 print(a==9 and b==30)
False
print(a==10 and b==30)
True
（2）逻辑或(or)：两边的表达式一个为真，结果就为真。一个为真，结果就为真。
a=10 b=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=10 b=[1,2,20,10] c=(1,2,10) print(a in b) print(a in c)
（2）not in 判断一个值不在另一个变量中
如下：a 不在 b序列中则返回True，否则返回False
a=1 b=[1,2,20,10] c=(3,2,10) print(a not in b) print(a not in c)
结果：
False
True
