python中的基本数据类型与基本运算符

引言

我们学习python语言是为了控制计算机、让计算机能够像人一样去工作，所以在python这门语言中，所有语法存在的意义都是为了让计算机具备人的某一项技能，这句话是我们理解后续所有python语法的根本。

一、变量

1. 什么是变量？
   变量就是可以变化的量，量指的是事物的状态，比如人的年龄、性别、体重，游戏角色的等级、金钱等等

2. 为什么要有变量？
   为了让计算机能够像人一样去记忆事物的某种状态，并且状态是可以发生变化的。
   程序执行的本质就是一系列状态的变化，变是程序执行的直接体现，所以我们需要有一种机制能够反映或者说是保存下来程序执行时状态，以及状态的变化。

3. 怎么使用变量（先定义、后使用）
   变量的定义由三部分组成，如下图
   

定义变量示范如下

name = 'laowang' # 记下人的名字为'laowang'
sex = '女'    # 记下人的性别为女性
age = 28      # 记下人的年龄为28岁
salary = 50000.12  # 记下人的薪资为50000.12元

解释器执行到变量定义的代码时会申请内存空间存放变量值，然后将变量值的内存地址绑定给变量名，通过变量名即可引用到对应的值。
通过变量名即可引用到值，我们可以结合print()功能将其打印出来

print(age) # 通过变量名age找到值28，然后执行print(28),输出：28

4. 变量名的命名规范
   变量名的命名应该见名知意
   如果我们要存储的数据28代表的是一个人的年龄，那么变量名推荐命名为age
   age = 28
   如果我们要存储的数据50代表的是一个人的等级，那么变量名推荐命名为level
   level = 50

       详细命名规范如下：
         1. 变量名只能是 字母、数字或下划线的任意组合
         2. 变量名的第一个字符不能是数字
         3. 关键字不能声明为变量名，常用关键字如下
         [
         ‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘exec’,
         ‘finally’, ‘for’, ‘from’,‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘not’, ‘or’, ‘pass’, ‘print’,
          ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’
         ]

   错误示范如下：

*a=123
$b=456
c$=789
2_name='laozhang'
123='ergouzi'
and=123
年龄=18 # 强烈建议不要使用中文命名

   正确示范如下

age_of_bert=30
page1='首页'
_class='江左盟'
name="狄仁杰"

5. 变量名的命名风格
   风格一：驼峰体

AgeOfJson = 86 
NumberOfStudents = 100

       风格二：纯小写下划线(在python中，变量名的命名推荐使用该风格)

age_of_json = 86 
number_of_students = 100

5. 变量值的三大特性
   变量的值具备三大特性
   1、id
   反应的是变量在内存中的唯一编号，内存地址不同id肯定不同
   2、type
   变量值的类型
   3、value
   变量值
   查看变量值三大特性的方式如下

>>> name = "laowang"
>>> id(name)
2425713164400
>>> type(name)
<class 'str'>
>>> name
'laowang'
>>>

---

二、常量

1. 什么是常量
   常量指在程序运行过程中不会改变的量
2. 为什么要有常量
   在程序运行过程中，有些值是固定的、不应该被改变，比如圆周率 3.141592653…
3. 怎么使用常量
   在Python中没有一个专门的语法定义常量，约定俗成是用全部大写的变量名表示常量。如：PI=3.14156。所以单从语法层面去讲，常量的使用与变量完全一致。

---

三、Python中的基本数据类型

我们学习变量是为了让计算机能够像人一样去记忆事物的某种状态，而变量的值就是用来存储事物状态的，很明显事物的状态分成不同种类的（比如人的年龄，身高，职位，工资等等），所以变量值也应该有不同的类型，例如

salary = 30000.12  # 用浮点型去记录薪资
age = 28  # 用整型去记录年龄
name = '老王'  # 用字符串类型去记录人名

1. int整型

作用：用来记录人的年龄，出生年份，学生人数等整数相关的状态
定义：

age=28
birthday=1992
salary=48000

2. float浮点型

作用：用来记录人的身高，体重，薪资等小数相关的状态
定义：

height=182.3

weight=145.6

salary=50000.12

数字类型的使用
1 、数学运算

>>> a = 2
>>> b = 3
>>> c = a + b
>>> c
5

2、比较大小

>>> x = 10
>>> y = 20
>>> x > y
False

3. 字符串类型str

作用：用来记录人的名字，家庭住址，性别等描述性质的状态
定义

name = 'Bert'

address = '北京市朝阳区'

sex = '男'

• 注意：用单引号、双引号、多引号，都可以定义字符串，本质上是没有区别的，但是
  1、需要考虑引号嵌套的配对问题
  message = “My name is Tony , I’m 18 years old!” 内层有单引号，外层就需要用双引号
  2、多引号可以写多行字符串

message = '''
       		 天青色等烟雨
      		 而我在等你
       		 夜色被打捞起
       		 隔江千万里
     	 '''

        3、 使用
             数字可以进行加减乘除等运算，字符串呢？也可以，但只能进行"相加"和"相乘"运算。

>>> name="bert"
>>> age="28"
>>> name+age  # 相加其实就是简单的字符串拼接,特别耗内存，不建议使用
'bert28'
>>> name*5   # 相乘就相当于将字符串相加了5次
'bertbertbertbertbert'
>>>

4. 列表list

作用：如果我们需要用一个变量记录多个学生的姓名，用数字类型是无法实现，字符串类型确实可以记录下来，比如
name_list=‘张三 李四 王五’，但存的目的是为了取，此时若想取出第二个学生的姓名实现起来相当麻烦，而列表类型就是专门用来记录多个同种属性的值（比如同一个班级多个学生的姓名、同一个人的多个爱好等），并且存取都十分方便
定义:

>>> name_list=['张三','李四','王五']

使用:

1. 列表类型是用索引来对应值，索引代表的是数据的位置，从0开始计数

>>> name_list=["张三","李四","王五"]
>>> name_list[0]
'张三'
>>> name_list[1]
'李四'
>>> name_list[2]
'王五'
>>>

2. 列表可以嵌套，嵌套取值如下

>>> students_info=[
["zhangliang",18,['sleep','jump']],
['direnjie',28,['sing','movies']]
]
>>> students_info[1][2][1]  # 取出王者峡谷第二个学生的第二个爱好
'movies'
>>>

5. 字典dict

作用：如果我们需要用一个变量记录多个值，但多个值是不同属性的，比如人的姓名、年龄、身高，属性各不相同，用列表可以存，但列表是用索引对应值的，而索引不能明确地表示值的含义，当需要记录的信息足够多时，就会容易造成混乱。这就用到新的数据类型即字典类型，字典类型是用key：value形式(键值对)来存储数据，其中key可以对value有描述性的功能
定义

>>> person_info={"name":"daji","age":18,"height":"180"}

使用：

• 1、字典类型是用key来对应值，key可以对值有描述性的功能，通常为字符串类型

>>> person_info={"name":"daji","age":18,"height":"180"}
>>> person_info["name"] # 取姓名
'daji'
>>> person_info["age"] # 取年龄
18
>>> person_info["height"] # 取身高
'180'
>>>

• 2、字典可以嵌套，嵌套取值如下

>>> students=[
 {'name':'吕布','age':38,'hobbies':['play','sleep','方天画戟']},
 {'name':'貂蝉','age':18,'hobbies':['read','sleep']}, 
 {'name':'孙尚香','age':58,'hobbies':['music','read','sleep','ak_47']}
 ]
>>> students[2]["hobbies"][3] # 取第3个学生的第四个爱好
'ak_47'
>>>

6. 布尔bool

作用：用来记录真假这两种状态
定义：

>>> is_ok = True
>>> is_ok = False

使用：通常用来当作判断的条件，我们将在if判断中用到它

---

四、计算机与用户交互

input 和print

1. 什么是与用户交互
   用户交互就是人往计算机中input/输入数据，计算机print/输出结果
2. 为什么要与用户交互？
   为了让计算机能够像人一样与用户沟通交流
   比如，过去我们去银行取钱，用户需要把帐号密码告诉柜员，而现在，柜员被ATM机取代，ATM机就是一台计算机，所以用户同样需要将帐号密码告诉计算机，于是我们的程序中必须有相应的机制来控制计算机接收用户输入的内容，并且输出结果
3. 如何与用户交互
   交互的本质就是输入、输出

• 输入input:
  在python3中input功能会等待用户的输入，用户输入任何内容，都存成字符串类型，然后赋值给等号左边的变量名

>>> username=input('请输入您的用户名：') 
请输入您的用户名：jack # username = "jack"
>>> password=input('请输入您的密码：') 
请输入您的密码：123 # password = "123"

注意：
1、在python2中存在一个raw_input功能与python3中的input功能一模一样
2、在python2中还存在一个input功能，需要用户输入一个明确的数据类型，输入什么类型就存成什么类型

# python2.7环境
>>> l=input('输入什么类型就存成什么类型: ')
输入什么类型就存成什么类型: [1,2,3]
>>> type(l)
<type 'list'>

• 输出print:

>>> print('hello world')  # 只输出一个值
hello world
>>> print('first','second','third')  # 一次性输出多个值，值用逗号隔开
first second third

默认print功能有一个end参数，该参数的默认值为"\n"(代表换行)，可以将end参数的值改成任意其它字符

print("aaaa",end='')
print("bbbb",end='&')
print("cccc",end='@')
#整体输出结果为：aaaabbbb&cccc@

输出之格式化输出

1. 什么是格式化输出？
   把一段字符串里面的某些内容替换掉之后再输出，就是格式化输出。
2. 为什么要格式化输出？
   我们经常会输出具有某种固定格式的内容，比如：'亲爱的xxx你好！你xxx月的话费是xxx，余额是xxx‘，我们需要做的就是将xxx替换为具体的内容。
3. 如何格式化输出？
   这就用到了占位符，如：%s、%d, format, python3.5之后推出了 f"his name is {name}"这种格式
   %s占位符：可以接收任意类型的值, %d占位符：只能接收整数数字

>>> print('亲爱的%s你好！你%s月的话费是%d，余额是%d' %('tony',12,103,11.11))
亲爱的tony你好！你12月的话费是103，余额是11

# 练习：接收用户输入，打印成指定格式
name = input('your name: ')
age = input('your age: ') #用户输入18,会存成字符串18,无法传给%d
print('My name is %s,my age is %s' %(name,age))

“”"

format填充与格式化

语法： 占位符：[填充字符][对齐方式][宽度]

先取到值,然后在冒号后设定填充格式为             占位符：[填充字符][对齐方式][宽度]
# *<10：左对齐，总共10个字符，不够的用*号填充
print('{0:*<10}'.format('开始执行')) # 开始执行******  0代表0号占位符

# *>10：右对齐，总共10个字符，不够的用*号填充
print('{0:*>10}'.format('开始执行')) # ******开始执行

# *^10：居中显示，总共10个字符，不够的用*号填充
print('{0:*^10}'.format('开始执行')) # ***开始执行***

精度与进制

print('{salary:.3f}'.format(salary=1232132.12351))  #精确到小数点后3位，四舍五入，结果为：1232132.124
print('{0:b}'.format(123))  # 转成二进制，结果为：1111011
print('{0:o}'.format(9))  # 转成八进制，结果为：11
print('{0:x}'.format(15))  # 转成十六进制，结果为：f
print('{0:,}'.format(99812939393931))  # 千分位格式化，结果为：99,812,939,393,931

Python格式化方法详解,请参考Python格式化字符串的几种方法详解

---

五、python中的基本运算符

1. 算术运算符
   ​ python支持的算数运算符与数学上计算的符号使用是一致的，我们以x=10，y=3为例来依次介绍它们

算术运算符	描述	示例
+	加，两个对象相加	x+y=13
-	减，两个对象相减	x-y=7
*	乘，两个对象相乘	x*y=30
/	除，结果保留整数与小数部分	x/y=3.3333333333333335
//	取整除(地板除)不四舍五入，结果只保留整数部分	x//y=3
%	取余，相除后返回余数	x%y=1
**	计算幂，取一个数的n次方	x**y=1000

2. 比较运算符
   ​ 比较运算用来对两个值进行比较，返回的是布尔值True或False，我们以x=10，y=3为例来依次介绍它们

比较运算符	描述	示例
==	等于，两个对象值相同返回True,否则返回False	x==y 得False
!=	不等于，两个对象值相同返回False， 否则返回True	x != y 得True
>	大于	x>y 得True
>=	大于等于	x>=y 得True
<	小于	x<y 得 False
<=	小于等于	x<=x 得True

3. 赋值运算符
   ​ python语法中除了有=号这种简单的赋值运算外，还支持增量赋值、链式赋值、交叉赋值、解压赋值，这些赋值运算符存在的意义都是为了让我们的代码看起来更加精简。我们以x=10，y=3为例先来介绍一下增量赋值

• 3.1 增量赋值

赋值运算	描述	示例
=	简单赋值运算	x=10
+=	加法赋值运算	x+=1 等同于 x=x+1，得x=11
-=	减法赋值运算	x-=1 等同于x = x-1， 得 x=9
*=	乘法赋值运算	y = 2 等同于 y=y2，得 y=6
/=	除法赋值运算符	x/=3 等同于x= x/3，得 x = 3.3333333333333335
//=	向下取整赋值运算	x //= y 等同于 x= x//y，得 x= 3
%=	取余赋值运算	x%=y 等同于 x=x%y，得x=1
**=	幂赋值运算	x**=y 等同于 x= x**y，得 x=1000

• 3.2 链式赋值
  如果我们想把同一个值同时赋值给多个变量名，可以这么做

>>> z=10
>>> y=z
>>> x=y
>>> x,y,z
(10, 10, 10)

链式赋值指的是可以用一行代码搞定这件事

>>> x=y=z=10
>>> x,y,z
(10, 10, 10)

• 3.3 交叉赋值
  我们定义两个变量m与n

>>> m=10
>>> n=20

如果我们想将m与n的值交换过来，可以这么做

>>> temp=m
>>> m=n
>>> n=temp
>>> m,n
(20, 10)

交叉赋值指的是一行代码可以搞定这件事

>>> m=10
>>> n=20
>>> m,n=n,m # 交叉赋值
>>> m,n
(20, 10)

• 3.4 解压赋值
  如果我们想把列表中的多个值取出来依次赋值给多个变量名，可以这么做

>>> nums=[11,22,33,44,55]
>>> 
>>> a=nums[0]
>>> b=nums[1]
>>> c=nums[2]
>>> d=nums[3]
>>> e=nums[4]
>>> a,b,c,d,e
(11, 22, 33, 44, 55)

解压赋值指的是一行代码可以搞定这件事

>>> a,b,c,d,e=nums # nums包含多个值，就好比一个压缩包，解压赋值因此得名
>>> a,b,c,d,e
(11, 22, 33, 44, 55)

注意，上述解压赋值，等号左边的变量名个数必须与右面包含值的个数相同,否则会报错

#1、变量名少了
>>> a,b=nums
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

#2、变量名多了
>>> a,b,c,d,e,f=nums
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 6, got 5)

但如果我们只想取头尾的几个值，可以用*_匹配

>>> a,b,*_=nums
>>> a,b
(11, 22)

ps：字符串、字典、元组、集合类型都支持解压赋值

4. 逻辑运算符
   ​ 逻辑运算符用于连接多个条件，进行关联判断，会返回布尔值True或False

逻辑运算符	描述	示例
and	逻辑与，用来连接两个条件，两个条件同时成立才返回True，但凡有一个条件为False，则返回False	3>1 and 4==4 返回True； 1>2 and 10>5 返回False
or	逻辑或，用来连接两个条件，两个条件但凡有一个成立就返回True，只有两个条件同时为False时才返回False	1>2 or 3>1 返回True； 1>2 or 5>10 返回 False
not	取反	not 1>2 返回True

4.1 连续多个and
可以用and连接多个条件，会按照从左到右的顺序依次判断，一旦某一个条件为False，则无需再往右判断，可以立即判定最终结果就为False，只有在所有条件的结果都为True的情况下，最终结果才为True。

>>> 2>1 and 1!=1 and True and 3>2 # 判断完第二个条件，就立即结束，得的最终结果为False
False

4.2 连续多个or
可以用or连接多个条件，会按照从左到右的顺序依次判断，一旦某一个条件为True，则无需再往右判断，可以立即判定最终结果就为True，只有在所有条件的结果都为False的情况下，最终结果才为False

>>> 2 > 1 or 1 != 1 or True or 3 > 2 # 判断完第一个条件，就立即结束，得的最终结果为True
True

4.3 优先级not>and>or

#1、三者的优先级关系：not>and>or，同一优先级默认从左往右计算。
>>> 3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3
False

#2、最好使用括号来区别优先级，其实意义与上面的一样
'''
原理为：
(1) not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割

(2) 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可

(3) 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算
'''
>>> (3>4 and 4>3) or (1==3 and 'x' == 'x') or 3 >3
False 

#3、短路运算：逻辑运算的结果一旦可以确定，那么就以当前处计算到的值作为最终结果返回
>>> 10 and 0 or '' and 0 or 'abc' or 'egon' == 'dsb' and 333 or 10 > 4
我们用括号来明确一下优先级
>>> (10 and 0) or ('' and 0) or 'abc' or ('abc' == 'def' and 333) or 10 > 4
短路：       0      ''            'abc'                    
            假     假              真

返回：                            'abc'

#4、短路运算面试题：
>>> 1 or 3
1
>>> 1 and 3
3
>>> 0 and 2 and 1
0
>>> 0 and 2 or 1
1
>>> 0 and 2 or 1 or 4
1
>>> 0 or False and 1
False 

5. 成员运算符

成员运算符	描述	示例
in	某一个对象包含于另一个对象则返回True,字符串，列表，元组，集合,字典都支持成员运算符	‘hello’ in ‘hello world’ 返回True；“age” in {“name”:“zhangsan”,“age”:18} 返回True #注意，判断的是字典的key
not in	某一个对象没有包含于另外一个对象返回True	“abc” not in “hello world” 返回 True

注意：虽然下述两种判断可以达到相同的效果，但我们推荐使用第二种格式，因为not in语义更加明确

>>> not 'lili' in ['jack','tom','robin']
True
>>> 'lili' not in ['jack','tom','robin']
True

6. 身份运算符

身份运算符	描述	示例
is	is比较的是id,两个对象的id相同，返回True id相同值肯定相同	x=10 y=x x is y 返回True
is not	两个对象的id不同时 is not 返回True	x=‘xxx’,y=‘mmm’ x is not y 返回True

需要强调的是：==双等号比较的是value是否相等，而is比较的是id是否相等

#1. id相同，内存地址必定相同，意味着type和value必定相同
#2. value相同type肯定相同，但id可能不同,如下
>>> x="zhenji is beautiful"
>>> y="zhenji is beautiful"
>>> id(x),id(y) # x与y的id不同，但是二者的值相同
(2766942596752, 2766943973984)
>>> x == y # 等号比较的是value
True
>>> type(x),type(y) # 值相同type肯定相同
(<class 'str'>, <class 'str'>)
>>> x is y # is比较的是id，x与y的值相等但id可以不同
False