【Python】04、python基础数据类型与运算符

lidonghe

　　1、常量和变量
　　2、基本数据类型
　　3、运算符
　　一、常量与变量
　　1、常量
　　常量：其值不变的量
　　一旦赋值，其值就不可再改变;
　　就是说不能再重新赋值，很像shell中的只读变量，python中不存在常量
　　字面常量：一个单独出现的量，未赋值给任何变量或常量。
　　2、变量
　　变量：其值可变的量
　　是一个名字，在赋值符号的左边，这个名字可以指代复制符号右边的内容
　　python将所有数据存为内存对象，变量本质上是指内存对象的引用，变量名和内存对象是分开存放的
　　变量命名规则
　　只能包含字母、数字和下划线，且不能以数字开头
　　区分字母大小写，禁止使用保留字
　　python强类型动态语言：
　　强类型语言：指不同类型之间的对象不能相互运算
　　动态语言：一种在运行期间才去确定数据类型的语言
　　在任何时刻，只要需要，某个对象引用都可以重新引用一个不同的对象（可以用不同的数据类型）
　　赋值符号“=”用于将变量名与内存中的某对象绑定：如果对象事先存在，就直接进行绑定；否则，则由“=”创建引用的对象
　　二、python的基本数据类型
　　1、数值类型
　　int：整型，整数
　　python中int原则上来说无限大，没有溢出；没有长度限制，只受制于内存的大小
　　python2中区分有int和long(长整型），python3中没有区分
　　float：浮点型，小数
　　float有长度限制，会溢出，会损失精度
　　python中没有double类型
In [25]: print(12.0003)　　
12.0003
　　

　　
In [24]: print(12.0000000000000000000000000000000000000000000000000003)
　　
12.0
　　complex：  复数
　　  复数与数学中的复数概念完全相同。Python中的复数有以下几个特性：
　　复数由实数部分和虚数部分构成，表示为：real+imagj 或 real+imagJ
　　复数的实部real和虚部imag都是浮点型
　　虚数不能单独存在,它们总是和一个实数部分(值可以为 0.0 )一起来构成一个复数。
　　虚数部分必须有后缀 j 或 J
　　当两个复数的实部相等，虚部互为相反数时，这两个复数叫做互为共轨复数.虚部不等于0的两个共轨复数也就做共轨虚数
In [73]: type(0.0j)　　
Out[73]: complex
　　

　　
In [67]: 3j.conjugate
　　
Out[67]: <function complex.conjugate>
　　

　　
In [68]: 3j.conjugate()      # 共轨复数
　　
Out[68]: -3j
　　

　　
In [69]: 3j.imag
　　
Out[69]: 3.0
　　

　　
In [70]: 3j.real
　　
Out[70]: 0.0
　　可以使用type()函数查看对象的类型：
In [59]: type(123)　　
Out[59]: int
　　

　　
In [60]: type("123")
　　
Out[60]: str
　　

　　
In [61]: type(-123)
　　
Out[61]: int
　　

　　
In [62]: type(1.23)
　　
Out[62]: float
　　abs()可以获取数值的绝对值：
In [65]: abs(-123)　　
Out[65]: 123
　　2、布尔类型
　　bool类型
　　布尔型其实是整型的子类型，布尔型数据只有两个取值：True和False，分别对应整型的1和0。
　　每一个Python对象都天生具有布尔值（True或False），进而可用于布尔测试（如用在if、while中）。
　　以下对象的布尔值都是False：

• 　　None
  
• 　　False（布尔型）
  
• 　　0（整型0）
  
• 　　0.0（浮点型0）
  
• 　　0.0+0.0j（复数0）
  
• 　　''（空字符串）
  
• 　　[]（空列表）
  
• 　　()（空元组）
  
• 　　{}（空字典）
  
• 　　用户自定义的 类实例，该类定义了方法 __nonzero__() 或 __len__()，并且这些方法返回0或False
  

　　除开上述对象之外的所有其他对象的布尔值都为True。
In [33]: type(True)　　
Out[33]: bool
　　

　　
In [34]: type(true)
　　
---------------------------------------------------------------------------
　　
NameError                                 Traceback (most recent call last)
　　
<ipython-input-34-83ab3fb73e0b> in <module>()
　　
----> 1 type(true)
　　

　　
NameError: name 'true' is not defined
　　

　　
In [35]: type("True")
　　
Out[35]: str
　　可以使用bool()函数查看对象的bool值：
In [40]: bool()　　
Out[40]: False
　　

　　
In [56]: bool("")
　　
Out[56]: False
　　

　　
In [57]: bool(" ")
　　
Out[57]: True
　　3、None类型
　　None类型只有一个None，表示什么都没有，没有指向任何内存区域
In [74]: type(None)　　
Out[74]: NoneType
　　4、type类型
In [75]: type(str)　　
Out[75]: type
　　

　　
In [76]: type(int)
　　
Out[76]: type
　　

　　
In [77]: type(float)
　　
Out[77]: type
　　三、运算符
　　1、算术运算符
　　算术运算符只能对数值类型运算
　　+、-、*、/、
　　除法在python3中是自然除法，结果一定是float；在python2中是取整除，没有//
In [108]: 3 / 2　　
Out[108]: 1.5
　　

　　
In [109]: 4 / 2
　　
Out[109]: 2.0
　　

　　
In [112]: 4 / 3
　　
Out[112]: 1.3333333333333333
　　

　　
In [110]: 3 // 2
　　
Out[110]: 1
　　

　　
In [111]: 4 // 2
　　
Out[111]: 2
　　

　　
In [113]: 4 // 3
　　
Out[113]: 1
　　//（取整除）、**（求幂）、%（取模）
　　通常取模运算也叫取余运算，它们返回结果都是余数，它们唯一的区别在于:
　　x % y：当x和y的正负号一样的时候，两个函数结果是等同的；当x和y的符号不同时，取余结果的符号和x的一样，而取模和y一样。
　　在C语言中，%符号表示的是求余运算，在Python脚本中，%表示的是取模。（通常取模运算中b不允许是负数，但是在python 2.5.1里可以在%后面跟负数，因为python语言中除法的结果是向0舍入，因此计算结果是取模！）
In [91]: 5 % -2　　
Out[91]: -1
　　

　　
In [92]: -5 % 2
　　
Out[92]: 1
　　2、比较运算符
　　>、<、==、!=、>=、<=
　　比较运算符的返回值一定是bool类型
In [114]: 3 > 2　　
Out[114]: True
　　

　　
In [115]: 3 > 5
　　
Out[115]: False
　　3、逻辑运算符
　　逻辑运算符的操作数都是bool类型或者可以隐式转化成bool类型的类型，返回值也是bool类型
　　and、no、tor
In [124]: 1 and 0　　
Out[124]: 0
　　

　　
In [125]: True and False
　　
Out[125]: False
　　

　　
In [126]: 1 or 0
　　
Out[126]: 1
　　逻辑运算的短路操作：
　　从左到右执行，当已经有结果的时候，将停止计算，提前返回
In [127]: 3 and 4　　
Out[127]: 4
　　

　　
In [128]: 3 or 4
　　
Out[128]: 3
　　

　　
In [129]: "abc" and 1
　　
Out[129]: 1
　　

　　
In [141]: "abc" or 1
　　
Out[141]: 'abc'
　　

　　
In [142]: print(3) and print(4)
　　
3
　　

　　
In [143]: print(3) or print(4)
　　
3
　　
4
　　4、身份操作符
　　is：判定左端对象引用是否相同于右端对象引用
In [149]: name = "xxj"　　

　　
In [150]: man = "xj"
　　

　　
In [151]: name is man
　　
Out[151]: False
　　

　　
In [153]: name is "xxj"
　　
Out[153]: True
　　
　　5、成员运算符
　　in或not in：测试成员关系
In [156]: "xj" in "xxj"　　
Out[156]: True
　　

　　
In [157]: "xj" not in "xxj"
　　
Out[157]: False
　　6、位运算符

　　位运算是在二进制层面操作；python中位运算很少，可以不关注
In [7]: 3<<3          # 就是在用二进制表示向左移动3位，加3个0　　
Out[7]: 24
　　

　　
In [8]: 24>>3         # 就是在用二进制表示向向移动3位，去掉前3位，剩下2位就是2**0+2**1=3
　　
Out[8]: 3
　　

　　
In [9]: 9<<3
　　
Out[9]: 72
　　

　　
In [10]: 9>>3
　　
Out[10]: 1
　　

　　
In [11]: 10>>3
　　
Out[11]: 1
　　

　　
In [12]: 20>>3
　　
Out[12]: 2
　　

　　
In [14]: 56>>3
　　
Out[14]: 7
　　7、运算符的优先级
　　算术运算 > 比较运算 > 逻辑运算
　　但可以通过括号类改变优先级
　　拿不准或表达式比较复杂的时候，使用括号来决定优先级
　　8、赋值运算符
　　赋值运算符可以和算术运算符，位运算符一起使用
In [163]: i = 3　　

　　
In [164]: i += 5
　　

　　
In [165]: i
　　
Out[165]: 8
　　四、程序控制语句
　　1、表达式和语句
　　表达式：
　　常量/变量和运算符一起构成
　　表达式一般都有返回值（除了复制表达式）
　　语句：
　　关键字和表达式一起组成语句
　　语句一般没有返回值（返回值为None）
　　注意：
　　在python中除了行首的空格以外都没有意义。加空格只是为了增加代码的可读性