首页 > 代码库 > 【Python】04、python基础语法

【Python】04、python基础语法


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类型

     布尔型其实是整型的子类型,布尔型数据只有两个取值:TrueFalse,分别对应整型的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类型

      andnotor

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、成员运算符

innot 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中除了行首的空格以外都没有意义。加空格只是为了增加代码的可读性



【Python】04、python基础语法