[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='';type(i)

Out[6]: str

2. python是强类型语言：强类型指的是不同类型之间不能相互计算

In [7]: 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')

    ...: