02. Python基础知识

一、注释

  在开发程序过程中，如果一段代码的逻辑比较复杂，不是特别容易理解，可以适当添加注释，以辅助自己或其他开发人员解读代码。注释是给程序员看的，为了让程序员方便阅读代码，解释器会忽略注释。在 Pyton 中，注释分为单行注释和多行注释。

• 单行注释：在 Python 中，使用 “#” 作为单行注释，从符号 “#” 开始直到换行为止
• 多行注释：在 Python 中，以一对三个引号（单引号和双引号都行）引起来的内容为多行注释

# 这是一个单行注释
print("Hello world!")   # print()函数可以向终端打印一段话

'''
    这是一个多行注释
'''

"""
    这同样也是一个多行注释
"""

“#” 与注释的内容建议以一个空格隔开

二、关键字

三、变量

  变量（variable），就是可以变量的量，它可以用来保存字面量，并且变量中保存的字面量是不定的。变量本身没有任何意思，它会根据不同的字面值表示不同的意思。

  在 Python 中使用变量，不需要声明，直接为变量赋值即可。

变量名 = 变量值

a = 10
print(a)

  但是不能使用没有赋值的变量，如果使用没有赋值过的变化，会报错；

b
print(b)

  这段代码在执行后，会报如下的错误：

Traceback (most recent call last):
  File "e:/Source/Software/python/template.py", line 1, in <module>
    b
NameError: name 'b' is not defined

  Python 是一个动态类型的语言，可以为变量赋任何类型的值，也可以任意修改变量的值；在 Python 中，使用内置函数 type() 可以返回变量的类型。

a = 10
print(a)
# 使用type()函数可以查看变量的类型
print(type(a))

a = "hello"
print(a)
print(type(a))

  在 Python 中允许多个变量指向同一个值，可以使用 id() 函数返回变量所指向的内存地址。

a = b = 123
print(a)
print(id(a))

print(b)
print(id(b))

Python 中变量的使用原则是先定义在使用；

在 Python 中，使用内置函数 type() 可以返回变量类型，使用内置函数 id() 可以返回变量所指的内存地址；

四、常量

  常量 就是程序运行过程中，值不能改变的量。在 Python 中，并没有提供定义常量的保留字，不过在 PEP 8 规范中规定了常量由大写字母和下划线组成，但是在实际项目中，常量首次赋值后，还是可以被其它代码修改的。

USER_ID = 1001
print(USER_ID)

USER_ID = 1002
print(USER_ID)

五、标识符

  标识符 可以简单的理解为一个名字，它主要用来标识变量、函数、类、模块 和 其它对象的名称。

5.1、标识符的命名规则

• 标识符中可以包含字母、数字、_，但是不能使用数字开头
• 标识符不能是 Python 中的关键字和保留字
• 标识符区分大小写

如果使用不符合标准的标识符，将会报错：SyntaxError: invalid syntax

5.2、标识符的命名规范

  在 Python 中主要遵循两种命名规范：

• 下划线命名法
  • 所有单词小写，单词之间使用 _ 分隔
• 帕斯卡命名法（大驼峰命名法）
  • 每个单词的首字母大写，其余字母小写

不建议使用 Python 中的函数名作为标识符；

六、数据类型

  数据类型 指的是变量值的类型，也就是可以为变量赋哪些值。我们可以通过 type(变量) 的方式查看变量存储的数据类型。在 Python 中，变量是没有类型的，但是它存储的数据有类型。

6.1、数值类型

  数值类型 是不可变类型，如果修改数值类型变量的值，那么会先把该值存放在新开辟的内容中，然后修改变量让其指向新的内存地址。在 Python 语言中，数值类型主要包括 整数、浮点数 和 复数。

6.1.1、整数类型

  整数 用来表示整数值，即没有小数部分的数值。在 Python 语言中，整数 包括 正整数、负整数 和 0，并且它的位数是任意的。整数类型包括 十进制整数、八进制整数、十六进制整数 和 二进制整数。

a = 10
print(a)                # 整数
# 使用type()函数可以查看变量的类型
print(type(a))
print(id(a))

a = 0b10                # 二进制的10  
print(a)
print(id(a))

a = 0o10                # 八进制的10
print(a)
print(id(a))

a = 0x10                # 十六进制的10
print(a)
print(id(a))

  在书写很大的数时，可以使用下划线将其中的位分组，使其更加清晰易读。当我们打印这种使用下划线的数时，Python 不会打印其中的下划线。这时因为在存储这种数时，Python 会忽略其中的下划线。在对数字位分组时，即使不是将每个三位分成一组，也不会影响最终的值。

num = 100_000_000
print(num)
print(type(num))

num = 1_0000_0000
print(num)

Python 中的整数大小没有限制，可以是一个无限大的整数；

如果数字过大，可以使用下划线作为分隔符；

其它进制的整数，默认是以是十进制的形式打印的；

十进制整数的不能以 0 开头；

6.1.2、浮点类型

  浮点数 由 整数部分 和 小数部分 组成，主要用于处理包括小数的数。浮点数可以使用科学计数法表示。

a = 3.14            # 浮点数
print(a)
print(type(a))

6.1.3、复数类型

  Python 中的 复数 与数学中的复数形式一致，都是由 实部 和 虚部 组成，并且使用 j 或 J 表示虚部。当表示一个复数时，可以将其实部和虚部相加。

a = 3 + 1j            # 复数
print(a)
print(type(a))

6.2、布尔类型

  布尔类型 主要用于表示 真值 或 假值。在 Python 中，标识符 True 和 False 被解释为 布尔值。另外，Python 中的布尔值可以转化为整数值，True 表示 1，False 表示 0。

  在 Python 中，所有的对象都可以进行真值测试，其中只有下面列出的几种情况得到的值为假。

• False 或 None
• 数值中的零，包括 0、0.0、虚数0
• 空序列，包括 字符串、空元组、空列表、空字典
• 自定义对象的实例，该对象的 __bool__ 方法返回 False 或者 __len__ 方法返回 0

a = True
print(a)
print(type(a))

a = False
print(a)
print(type(a))

6.3、序列

  Python 序列（Sequence）是指按特定顺序依次排列的一组数据，它们可以占用一块连续的内存，也可以分散到多块内存中。Python 中的序列类型包括 字符串（str）、列表（list）、元组（tuple）、字典（dict）和 集合（set）。

6.3.1、字符串类型

  字符串 就是连续的字符序列，可以是计算机所能表示的一切字符的集合。在 Python 中，字符串属于不可变序列，通常使用 单引号（‘’）、双引号（“”） 或 三引号（‘’‘’‘’ 或 “”“”“”）括起来。这三种引号形式在语义上没有差别，只是在形式上有些差别。其中 单引号 和 双引号 中的字符必须在同一行上，而 三引号 内的字符序列可以分步在连续的多行上。

a = 'hello world!'
print(a)
print(type(a))

a = "Sakura"
print(a)

a = """hello
my name is Sakura"""
print(a)

a = '''
hello world
你好，世界！
'''
print(a)

  Python 中的字符串还支持转义字符。转义字符 是使用 反斜杠（\）对一些特殊字符进行转义。常见的转义字符如下：

print("hello \
    world!")
print("\thello")
print("鲁迅说：\"这句话我从未说过\"")
print("子曰：\'学而时习之，不亦说乎！\'")
print("御坂美琴 夏娜\r木之本樱")
print("\\")
print("你好，\n世界")
print("Sakura \bKinomoto")

6.3.2、列表类型

  Python 中列表是由一系列按特定顺序排列的元素组成的，它是 Python 中内置的可变序列。在形式上，列表的所有元素都放在一对中括号 “[]” 中，两个相邻元素间使用逗号 “,” 分隔。在内容上，可以将整数、实数、字符串、列表、元组等任何类型的内容放入到列表中，并且同一个列表中，元素的类型可以不同，因为它们之间没有任何关系。

# 列表中可以保存任意的对象
my_list = [10,"hello",True,None,[1,2,3]]
print(my_list)
print(type(my_list))

  列表中的对象都会按照插入的顺序存储到列表中，第一个插入的对象保存到第一个位置，第二个保存在第二个位置。我们也可以通过 索引 的方式获取指定的元素。索引 是元素在列表中的位置，列表中的每一个元素都有一个索引。索引是 0 开始的整数，列表第一个位置索引为 0，第二个位置索引为 1，依次类推。

names = ["Sakura","Mikoto","Shana"]
print(names[0])
print(names[1])
print(names[2])

  在 Python 中索引可以是 负数。这个索引从右向左计数，也就是从最后的一个元素开始计数，即最后一个元素的索引是 -1，倒数第二个第二个元素的索引值为 -2，以此类推。

names = ["Sakura","Mikoto","Shana"]
print(names[-1])
print(names[-2])
print(names[-3])

6.3.3、元组类型

  元组（tuple）是 Python 中的一种序列结构，和列表类似，也是由一系列按特定顺序排列的元素组成，但它是不可变序列。因此，元组也可以称为不可变的列表。在形式上，元素的所有元素都放在一对 “()” 中，两个相邻元素间使用 “,” 分隔。在内容上，可以将整数、实数、字符串、列表、元组等任何类型的内容放在元组中，并且在同一个元素中，元素的类型可以不同。

# 元组中可以保存任意的对象
my_tuple = (10,"hello",True,None,[1,2,3])
print(my_tuple)
print(type(my_tuple))

  元组中的对象都会按照插入的顺序存储到元组中，第一个插入的对象保存到第一个位置，第二个保存在第二个位置。我们也可以通过 索引 的方式获取指定的元素。索引 是元素在元组中的位置，元组中的每一个元素都有一个索引。索引是 0 开始的整数，元组第一个位置索引为 0，第二个位置索引为 1，依次类推。

names = ("Sakura","Mikoto","Shana")
print(names[0])
print(names[1])
print(names[2])

  在 Python 中索引可以是 负数。这个索引从右向左计数，也就是从最后的一个元素开始计数，即最后一个元素的索引是 -1，倒数第二个第二个元素的索引值为 -2，以此类推。

names = ("Sakura","Mikoto","Shana")
print(names[-1])
print(names[-2])
print(names[-3])

从元素和列表的定义上看，这两种结构比较相似，两者之间的主要区别为：元组是不可变序列，列表是可变序列。即元组的元素不可以单独修改，而列表可以任意修改。

6.3.4、字典类型

  在 Python 中，字典（dictionary）是一系列 键值对。每个键都与一个值关联，可以使用键来访问与之关联的值。字典中的 元键 只能是 不可变类型 的数据类型，也就是可哈希类型。与键相关的值可以是数字、字符串、列表 乃至字典等。事实上，可将任意的 Python 对象用作字典的值。

person = {"name":"Sakura","age":10}
print(person)
print(type(person))

  在 Python 中，我们可以通过 key 来获取它所对应的 value 值。

person = {"name":"Sakura","age":10}
print(person["name"])
print(person["age"])

如果使用的字典中不存在键会报以下错误：KeyError: 'gender'

字典不支持索引取值！

6.3.5、集合类型

  在 Python 中，集合与列表类似，集合它是无序（不是按照元素的插入顺序保存）的可变序列。在集合中不能出现重复的元素。在形式上，集合的所有元素都放在一对 “{}” 中，两个相邻元素间使用 “,” 分隔。集合中的元素只能是不可变类型的数据类型，也就是可哈希类型。

names= {"Sakura","Mikoto","Shana","Sakura"}
print(names)
print(type(names))

6.4、数据类型转换

  在 Python 中，提供了如下的函数用来进行数据类型的转化。

int(x, base=10)             # 将x转换为以base为进制的整数类型
float(x=0.0)                # 将x转换为浮点数类型
complex(real=0, imag=0)     # 创建一个复数
str(object='')              # 将x转换为字符串
chr(i)                      # 将整数x转换为一个字符
ord(c)                      # 将一个字符x转换为它对应的整数值
bin(x)                      # 将一个整数x转换为一个二进制的字符串
oct(x)                      # 将一个整数x转换为一个八进制的字符串
hex(x)                      # 将一个整数x转换为一个十六进制字符串

a = "3"
b = int(a)
print(b)
print(type(b))

a = "3.14"
b = float(a)
print(b)
print(type(b))

a = complex(1,2)
print(a)
print(type(a))

a = 3.14
b = str(a)
print(b)
print(type(b))

print(chr(97))                      # 将整数转换为字符
print(ord("a"))                     # 将字符转换为整数

print(int("15"))                    # 默认以十进制的形式读取字符串
print(bin(15))                      # 将十进制整数转换为二进制整数
print(int("0b1111",base=2))         # 以二进制的形式读取字符串
print(oct(15))                      # 将十进制整数转换为八进制整数
print(int("0o17",base=8))           # 以八进制的形式读取字符串
print(hex(15))                      # 将十进制整数转换为十六进制整数

类型转换不是改变对象本身的类型，而是根据当前对象的值创建一个新的对象；

以上的转换函数不会原有的变量产生影响，它是将对象转换位指定的类型并将其作为返回值返回，如果需要修改原来的变量，则需要对变量进行重新赋值；

七、基本输入输出

  默认情况下，在 Python 中，使用内置的 print() 函数将结果输出到控制台上，其基本语法格式如下：

print(输出内容)

  其中，输出内容可以是数字和字符串（字符串需要使用引号括起来），此类内容将直接输出，也可以是包含运算符的表达式，此类内容将计算结果输出。

  在 Python 中，默认情况下，一条 print() 语句输出后会自动换行，如果想要一次输出多个内容，而且不换行，可以将要输出的内容使用英文半角的逗号分隔。在输出时，也可以把结果输出到指定文件。

  在 Python 中，使用内置函数 input() 可以接收用户的接盘输入。input() 函数的基本用法如下：

变量名 = input("提示文本")

  其中，变量名 为保存用户输入结果的变量，引号内的内容用于提示要输入的内容。

  在 Python 3 中，无论输入的是数字还是字符都将被作为字符串读取。如果想要接收数值，需要把接收到的字符串进行类型转换。

name = input("请输入你的姓名：")
age = int(input("请输入你的年龄："))

print("name: ",name,", age: ",age)
print(type(name))
print(type(age))

八、编程规范

  Python 中采用 PEP 8 作为代码规范，其中 PEP 是 Python Enhancement Proposal 的缩写，翻译过来是 Python 增加建议书，而 “PEP 8” 的 8 是版本号。

1. 每个 import 语句应仅导入一个模块，避免依次导入多个模块；
2. 不要在行尾添加分号 “;”，也不要使用分号将两条命令放在同一行；
3. 建议每行不要超过 80 个字符，如果超过，建议使用小括号 “()” 将多行内容隐式的连接起来，而不推荐使用反斜杠反斜杠 “\” 进行连接；
4. 使用必要的空行可以增加代码的可读性。一般在顶级定义（如函数或类的定义）之间使用两行，而方法定义之间空一行。另外，在用于分隔某些功能的位置也可以空一行；
5. 通常情况下，运算符两侧、函数参数之间、逗号“,”两侧仅以使用空格进行分隔；
6. 应该避免在循环中使用 “+” 和 “+=” 运算符累加字符串。这是因为字符串是不可变的，这样做会创建不必要的临时对象。推荐将每个子字符串加入列表，然后在循环结束后使用 join() 方法连接列表；
7. 适当使用异常处理结构提高程序容错性，但不能过多依赖异常处理结构，适当显示的判断还是必要的；