Python基础语法与数据类型

1. 基础语法

1.1 编码

Python3中默认的编码为UTF-8,所有的字符串都是Unicode字符串，可以通过如下方式指定Python源文件的编码

# -*- coding: utf-8 -*-

上述方式指定了编码为UTF-8

1.2 标识符

标识符简单的说就是变量名，变量是程序中存储数据的基本单元，代表一个可以改变值的存储空间。Python和其它程序设计语言一样对于标识符是有约束的，具体约束如下：

• 标识符由数字、字母、下划线组成
• 第一个字符必须是下划线或者字母
• 区分大小写
• 不能使用保留字作为标识符

在Python3中，比较有意思的一点可以使用中文作为标识符，Java中也可以，只不过一般没有人这样做

保留字又称关键字，是程序中已经定义过的、语法中需要使用的，在Python3中可以通过keyword模块查看保留字

1.3 注释

注释是一种伪代码，Python3的解释器不会执行注释，注释一般作为对于程序解释，可以使代码具体很好的可读性。注释分为单行注释和多行注释：

• # 为单行注释

• “”" “”"或者’‘’ ‘’’ 为多行注释

# 单行注释
'''
多行注释
多行注释
'''

"""
多行注释
多行注释
"""
print('hello world!')

运行结果:

1.4 行结束与缩进

Python的语法的简介主要表现为在一行语句结束的时候不用使用==;作为结束标志，在表示代码块的时候不用{}而使用缩进，一个缩进为四个空格或者一个tab==，缩进是可以有多个的，相同的代码块需要相同的缩进。

# 判断闰年
year = 2004
if year % 100 == 0:
    if year % 400 == 0:
        print("Yes")
    else:
        print("No")
else:
    if year % 4  == 0:
        print("Yes")
    else:
        print("No")

1.5 多行语句

如果一条语句太长，可以使用==\==(反斜杠)来进行拼接

a = 1 + \
    2 + \
    3
print(a)

运行结果:

2. 数据类型

Python是一个弱类型的语言，对于变量不需要提前指定变量类型，解释器可以通过变量的值来自动推断变量的数据类型，并且变量可以是任意的数据类型，这一点和C\C++以及Java这种强类型的语言是不同的。

Python中的数据类型主要有分为如下几类:

• 数字类型
• 布尔类型
• 字符串类型
• 列表类型
• 元组类型
• 字典类型

其中数字类型可以分为:整型、浮点型、复数类型

2.1变量的定义

Python的变量不用声明数据类型，解释器会根据值来推断数据类型

# 变量名 = 值
# 定义变量a 值为1
a = 1
# 使用type()函数查看变量a的数据类型 类型为int 整型
type(a)
# 定义变量a 值为1.1
b = 1.1
# 使用type()函数查看变量b的数据类型 类型为float 浮点型
type(b)
# 定义变量c 值为'123'
c = '123'
# 使用type()函数查看变量c的数据类型 类型为str 字符串类型
type(c)
# 将变量a的值改为True 
a = True
# 使用type()函数查看变量a的数据类型 类型为bool 布尔型
type(a)
# 将变量a的值改为[1,2,3]
a = [1,2,3]
# 使用type()函数查看变量a的数据类型 类型为int 整型
type(a)
# 将变量a的值改为(1,2,3)
a = (1,2,3)
# 使用type()函数查看变量a的数据类型 类型为tuple 元组型
type(a)
# 将变量a的值改为{'a':1,b:2}
a = {'a':1,'b':2}
# 使用type()函数查看变量a的数据类型 类型为dict 字典型
type(a)

2.2 运算符

运算:就是对程序中各种数据类型的加工和处理的过程

运算符:表示运算的符号为运算符

操作数:参与运算的数据

Python中的运算符有如下几种

• 赋值运算符
• 算术运算符
• 比较运算符
• 逻辑运算符
• 成员运算符
• 身份运算符

2.2.1 赋值运算符

=====为赋值运算符，将右边的变量值或常量值赋给左边的变量

a = 1
b = c = a 
# 使用print()函数向标准输出打印内容
print(a,b,c)

2.2.2 算术运算符

算术运算符主要用于计算，和数学中的加、减、乘、除是差不多的

运算符	含义
+	加法
-	减法
*	乘法
/	除法 保留小数
//	除法 不保留小数
%	除法取余
**	次幂运算

# + 加法 1 + 1 = 2
print(1 + 1)
# - 减法 2 - 1 = 1
print(2 - 1)
# * 乘法 2 * 2 = 4
print(2 * 2)
# / 除法 保留小数 1 / 2 = 0.5
print(1 / 2)
# // 除法 不保留小数 1 // 2 = 0
print(1 // 2) 
# % 取余 1 % 2 = 1
print(1 % 2) 
# ** 次幂计算 2 ** 2 相当于2的2次方结果为4
print(2 ** 2)

对于运算符，一些运算符只能对相同类型的数据进行运算，还有一些运算符可以对不同类型的数据进行运算

# 整型 + 字符型会报错 不支持
print(1+'3')
# 字符型 * 整型 将字符串变为原来的3倍
print('1' * 3)

2.2.3 比较运算符

比较运算符用于对值的比较，结果为bool类型

运算符	含义
==	比较操作数是否相等
!=	比较操作数是否不相等
>	比较左边的操作数是否大于右边的操作数
<	比较左边的操作数是否小于右边的操作数
>=	比较左边的操作数是否大于或者等于右边的操作数
<=	比较左边的操作数是否小于或者等于右边的操作数

print(1 == 2)
print(1 != 2)
print(1 > 2)
print(1 < 2)
print(1 >= 2)
print(1 <= 2)

其中 > < >= <= 只支持数值类型的比较

2.2.4 逻辑运算符

运算符	含义
and	逻辑与，操作数都为True结果为True，否则为False
or	逻辑或，操作数都为False结果才为False，否则结果为True
not	逻辑非,对操作数结果进行取反即 False=> True，Ture => False

print(1 > 2 and 3 > 4)
print(1 > 2 or 3 > 4)
print(not 3 > 4)
# 运算符可以组合使用
print(not (1 > 2 and 3 > 4))

逻辑运算符要求操作数的类型为bool

and or 为双目运算符，对两个操作数进行操作

not 为单目运算符，对一个操作数进行操作

2.2.5 成员运算符

成员运算符就是对于列表、字符串、字典、元组这种复合数据类型进行运算的运算符，用于查看这些类型的变量中是否有指定的成员，如果有返回True，否则返回False

运算符	含义
in	在指定的复合数据类型中查找是否包含指定元素
not in	在指定的复合数据类型中查找是否不包含指定元素

# 查看列表[1,2,3,4]中是否包含元素1
print(1 in [1,2,3,4])
# 查看元组(3,4)中是否包含1
print(1 in (3,4))
# 查看字符串'1234'中是否包含 ‘1’
print('1' in '1234')
# 查看字典{1:'a',2:'b',3:'c'} 是否包含 1 
# 只会查看key中是否包含1 不会在value中查找
# 这与哈希的原理有关
print(1 in {1:'a',2:'b',3:'c'})

print(1 not in [1,2,3])
print('0' not in '1234')
print(3 not in (1,2,3,4))
print(3 not in {1:'a',2:'b',3:'c'})

2.2.6 身份运算符

身份运算符用于判断两个变量是否引用的同一个对象，是否指向同一块内存地址

运算符	含义
is	判断两个标识符是否引用自同一个对象，如果是返回True，否则返回False
not is	判断两个标识符是否引用自不同的对象，如果是返回True，否则返回False

Python中查看对象地址的方法为id()

a = 1
b = 2
id(1)
id(2)

身份运算符比较的就是两个对象或者变量的id()的值。

a is b
a is not b

2.3 数字类型(Number)

Python 数字数据类型用于存储数值,数字类型分为整型、浮点型和复数。

• 整型，Python中的整型相当于C语言中的long类型，没有限制大小
• 浮点型，由整数部分和小数部分组成，也是没有限制大小的，相当于C语言中的double
• 复数型，复数由实部和虚部组成，使用a+bj或者complex(a,b)表示，其中a代表实部，b代表虚部，a和b的类型都是浮点数

# 定义a，b变量分别赋值 1， 2
a = 1
b = 2
# 打印 a+b 的值
print(a+b)
# 将变量a赋值为2.2 此时a为float 浮点型
a = 2.2
# 定义变量c并将a+b的值赋值给c 此时c的值为2.2+2=4.2
# 整型 + 浮点型 = 浮点型 这里有一个整型->浮点型的自动类型提升
c = a + b
# 打印c的值
print(c)
# 使用type函数查看变量c的数据类型 为 float 
type(c)
# 定义变量d 值为 4 + 2j 变量d为complex复数类型
d = 4 + 2j
# c为浮点数 d为复数 将c+d的结果赋值给变量e
e = c + d
# 打印e的值 为 8.2 + 2j 也就是说 浮点数与复数进行运算 复数的实部的值会加上浮点数的值
# 浮点数 + 复数 = 复数 这里有一个 浮点型->复数型的自动类型提升
print(e)
# 查看变量e的数据类型为浮点型
type(e)

数值类型之间进行运算，存在自动类型转换，整型->浮点型->复数型

2.3.1 数值类型的类型转换

有时候我们需要对数值类型进行手动的转换，就会用到以下函数:

• int(x) 将x转换为一个整数。
• float(x) 将x转换到一个浮点数。
• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

# 定义变量 a b c a为整型 b 为浮点型 c为复数型
a = 1
b = 1.1
c = 2 + 2j
# 使用int()函数将浮点数b转换为整型
int(b)
# 使用int()函数将复数c转换为整型
int(c)
# 报错无法将complex转换为int
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't convert complex to int
# 使用float()函数将整型a转换为浮点型
float(a)
# 使用float()函数将复数c转换为浮点型
float(c)
# 报错无法将complex转换为float
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't convert complex to float
# 使用complex()函数将整型a转换为复数型
complex(a)
# 使用complex()函数将浮点型b转换为复数型
complex(b)
# 使用complex()函数将整型a作为实部，浮点型b作为虚部 转换为复数型
complex(a,b)

整型和浮点型之间可以相互转换，而复数型无法转换为整型或者浮点型，但是浮点型以及整型都可以转换为复数型

2.4 布尔类型(bool)

布尔类型用于表示逻辑真(True)或者假(False)，在Python中单词的首字母为大写

# 定义变量a、b 赋值为True或者False
a = True
b = False
# 将bool转换为整型 True转换为整型值为1  False转换为整型值为0
int(a)
int(b)

2.5 字符串类型(String)

字符串是一种字符序列，是一种比较常用的数据结构，Python中定义字符串可以使用单引号和双引号。

a = 'abc'
b = "abc"
print(a,b)

有时候需要存储多行文本数据，Python中可以使用多行字符串

a = """ abc
def
...
"""
b = '''
abc
def
... '''
>>> print(a,b)

多行注释其实就是字符串，只不过没有变量引用，Python中的单引号和双引号定义的字符串其实是有区别的。

2.6 列表类型(list)

列表是一个由不同类型组成的有序序列，相当于数据结构中的线性表，这里只简单的定义一下列表。

# 变量名 = [元素....]
a = [1,2,3,4,5]
print(a)

2.7 元组类型(tuple)

元组有点类似于C语言中的数组，但是一旦定义，里面元素的值无法被改变。

# 元组定义 变量名 = (元素....)
a = (1,2,3,4)
# 访问元组中的第一个元素 元素下标从0开始
a[0]
# 访问元组中的第三个元素
a[2]
# 这里尝试修改元组中的三个元素的值
# 报错 元组中的元组值不支持赋值
a[2] = 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

2.8 字典类型(dict)

字典类型存放key-value的数据类型，是一种哈希数据结构的实现。

# 定义字典 变量名 = {k:v,k:v....}
a = {'上单':'德莱厄斯','打野':'赵信','中单':'辛德拉','射手':'希尔','辅助':'巴德'}
# 获取key为'打野'的value值
a['打野']
# 将key为'打野'的修改为'卡兹克'
a['打野'] = '卡兹克'
# 获取key为'打野'的value值
a['打野']

小结

Python中使用缩进来表示代码块，并且语句结束不用;

Python是弱类型语言，无需声明变量的数据类型；根据变量的值来决定变量的数据类型的,因为解释器会自动推断，并且变量数据类型可以任意转换

Python中有比较丰富的运算符和数据类型