[PY3]——基本语法
Python3基本语法-xmind图
常量/变量
1. 常量：一旦赋值就不可再改变。不能对它重新赋值。python不存在常量
2. 字面常量：一个单独出现的量，未赋值给任何变量或常量
3. 变量:
i=3 print(i) 3
类型系统
1. python是动态类型语言：指的是变量可以重新赋值为其他类型
In [5]: i=4;type(i) Out[5]: int In [6]: i='4';type(i) Out[6]: str
2. python是强类型语言：强类型指的是不同类型之间不能相互计算
In [7]: 4+'4' TypeError: unsupported operand type(s) for +: 'int' and 'str'
3. python中一切都是引用，所以一切都是指针
4. python的基本类型：
(1)int整型：python里面可以说int型没有溢出，而只受限于物理内存
In [8]: i=1000000000000000000000000000000000000000000000000000000000000000000000 ...: 000000000000000000000000000000000000000000000000000000000000000000000000 In [9]: type(i) Out[9]: int In [10]: i**2 Out[10]: 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
(2)float浮点型：(py3里面没有double类型)，浮点型会损失精度
In [11]: type(1.0) Out[11]: float In [12]: type(3.14159) Out[12]: float
(3)bool布尔型：True Flase
(4)none：None指的是没有指向任何内存
运算符
1. 算术运算符：
# 算术运算符只能对int和float运算,int会隐式转换成float # + 加 In [5]: 1+1.0 Out[5]: 2.0 # - 减 In [6]: 1-2 Out[6]: -1 # * 乘 In [11]: 2*3 Out[11]: 6 # / 自然除(结果都是float型) In [1]: 3/2 Out[1]: 1.5 In [2]: type(3/2) Out[2]: float # // 取整除(结果取整故都是int型) In [3]: 3//2 Out[3]: 1 In [4]: type(3//2) Out[4]: int # ** 求幂 In [12]: 2**3 Out[12]: 8 # % 取模 In [19]: 4%3 Out[19]: 1
2. 比较运算符
# 比较运算返回值都是bool型 # > 大于 # < 小于 # == 等于 # != 不等于 # >= 大于等于 # <= 小于等于 In [20]: type(1>2) Out[20]: bool In [21]: 1>2 Out[21]: False In [22]: 1<2 Out[22]: True In [23]: 1!=2 Out[23]: True
3. 逻辑运算符
# or 或 # and 且 # not 非 # 逻辑运算符的操作数与返回值都是bool类型 In [24]: True or False Out[24]: True In [25]: True and False Out[25]: False In [26]: not True Out[26]: False In [27]: type(True or False) Out[27]: bool # 所有参与逻辑运算的操作数都会隐式转换成bool类型，其中0和None会隐式转换为False、非0则隐式转换为True In [31]: 0 or 1 //0=Flase or 1=True Out[31]: 1 //非0=True # 逻辑运算的短路操作：从左到右执行，当左边的计算已经可以直接得出结果时，将停止计算，提前返回 In [32]: def true(): print('True') return True In [34]: def false(): print('False') return False In [35]: true() or false() True //or运算时左边为true已可以得到结果，故只执行了true() Out[35]: True In [36]: false() and true() False //and运算时左边为false已可以得到结果，故只执行了false() Out[36]: False In [37]: false() or true() //左边还不能得到结果的时候，true()和false()都执行了 False True Out[37]: True
4. 成员运算符
#用于判断一个元素是否在容器中（和集合类型有关） # in 在 # not in 不在 In [43]: 3 in [1,2,3,5] Out[43]: True In [46]: 'a' not in 'love python' Out[46]: True In [47]: 10 in (0,2,8,11) Out[47]: False In [44]: 10 in {0,2,8,11} Out[44]: False # 集合的成员运算远高于其他线性结构做成员运算 # 列子1： In [49]: lst=list(range(1000000)); In [50]: s=set(range(1000000)); In [51]: %%timeit ...: -1 in lst 100 loops, best of 3: 13.1 ms per loop In [52]: %%timeit ...: -1 in s The slowest run took 28.53 times longer than the fastest. This could mean that an intermediate result is being cached. 10000000 loops, best of 3: 44.6 ns per loop #例子2： In [53]: lst2=list(range(100)) In [54]: s2=set(range(100)) In [55]: %%timeit ...: -1 in lst2 1000000 loops, best of 3: 1.36 us per loop In [56]: %%timeit ...: -1 in s2 The slowest run took 26.28 times longer than the fastest. This could mean that an intermediate result is being cached. 10000000 loops, best of 3: 46.3 ns per loop # 通过下面的例子我们可以得到如下结论： # 做成员运算时， # *集合的时间复杂度是O(1),其效率和集合的规模无关 ==>当规模大时我们转化为集合来做运算效率会高很多 # *线性结构的复杂度是O(n),其效率和列表的规模有关 ==>当规模小时其实线性结构的效率未必不会更好
5. 身份运算符
# 面向对象
6. 位运算符
# 位运算符是直接操作二进制的 # << # >> # & # | # ^
7. 赋值运算符
# 赋值运算符是可以和算术运算符、比较运算符、位运算符一起使用 In [12]: a=1+2;print(a);type(a) 3 int In [13]: a=1>2;print(a);type(a) False bool In [14]: a=True or False;print(a);type(a) True bool
8. 运算符优先级
算术运算符>比较运算符>逻辑运算符
可以通过使用括号来改变优先级
程序结构
1. 顺序结构
2. 分支结构
（1）单分支 （2）双分支
（3）多分支
# 单分支
开始
if 条件:
操作
结束 In [1]: a=5 In [2]: if a<10: print('a less then 10') # 双分支双分支结构里，永远只有一个分支会被执行
开始
if 条件:
操作1
else:
操作2
结束 In [3]: a=5 In [4]: if a<10: print(a,'less then 10') else: print(a,'great then 10') # 多分支多分支结构里，永远只有0个或1个分支会执行条件只能是bool类型或者是可以隐式转化为bool类型的 In [5]: a=50 In [6]: if a<10: print('a<10') elif a<20: print('a<20') elif a<30: print('a<30') else print('a>30')
3. 循环
（1）while循环 （2）for in循环
# 一定要有某种机制修改调制使其退出循环，通常是在循环体里修改条件 # for in 循环里永远不要修改可迭代对象（）
# 如何选择使用哪种循环？
对已知的可迭代对象做遍历，选择for in
对未知的条件做循环，选择while
# while循环
开始
while 条件:
操作
结束 In [18]: i=0 In [19]: while i<10: print(i) i+=2 0 2 4 6 8 # for in循环
开始
for 元素 in 可迭代对象:
操作
结束 In [62]: for i in range(0,10,2): print(i) 0 2 4 6 8
4. 提前终止与跳过
# break 和 continue只针对最近的一层 # break和continue只能用在循环里 # break In [66]: for i in range(0,3): ...: for j in range(0,5): ...: if j>2: ...: break ...: print('i={},j={}'.format(i,j)) ...: i=0,j=0 i=0,j=1 i=0,j=2 i=1,j=0 i=1,j=1 i=1,j=2 i=2,j=0 i=2,j=1 i=2,j=2 # continue In [67]: for i in range(0,3): ...: for j in range(0,5): ...: if j!=2: ...: continue ...: print('i={},j={}'.format(i,j)) ...: i=0,j=2 i=1,j=2 i=2,j=2
5. else子句(python中else可以和循环语句一起使用)
# 当循环没有被break（被中断/提前退出）时，会执行else子句 In [68]: for i in range(0,5): ...: pass ...: else: ...: print('not exit') ...: not exit In [69]: for i in range(0,5): ...: continue ...: else: ...: print('not exit') ...: not exit In [70]: for i in range(0,5): ...: break ...: else: ...: print('not exit') ...:
