第二章 基础语法与数据类型 v1.0

第一部分 基础语法

一、注释

注释是一种对代码进行解释和说明的形式，它可以出现在代码的任何位置，不会被编译器或解释器执行。在代码编写过程中加入合适的注释可以帮助其他开发者更好地理解和维护代码。

---

在Python中，我们可以使用以下两种方式来添加注释：

1. 单行注释：采用'#'表示一行注释的开始
2. 多行注释：使用三个单引号(') 或者三个双引号 (") 来包含注释内容

单行注释

# 这是一行注释
a+b # 这是代表a+b的一个表达式

多行注释

"""
这是多行注释
"""
'''
这也是多行注释
'''

而在Python中，多行注释和多行字符串在语法上非常相似，它们都使用三个引号括起来，并且可以跨越多行，故在此处再介绍一下**多行字符串 **。

多行字符串是用于表示跨越多行的文本的一种字符串，它会保留原始文本的格式，即字符串中的空格、制表符和换行符都会被保留，它与多行注释的主要区别是多行注释会在代码执行时被忽略，而多行字符串会被当作有效的代码。

多行字符串

multiline_string = """这是一个
   多行字符串"""  #实际存储信息：这是一个\n   多行字符串
s = "这是一个\n   多行字符串"
print(multiline_string == s) # output: True

二、代码块

---

1.行与缩进

Python中与其他语言最大的区别也是最明显的一个特点的就是使用缩进来表示代码块(对于强迫症来说非常友好~)，缩进的空格数( 或制表符个数)是可变的，但是同一个代码块的语句必须包含相同的缩进空格数(或制表符个数)，示例如下：

正确示例

for i in range(100):
    print(i)
    print(i*i)

错误示例

for i in range(100):
    print(i)
  print(i*i)  # IndentationError: unindent does not match any outer indentation level  => 缩进错误

一般来说，Python中通常使用4个空格来表示一个缩进级别，因为因为不同的编辑器对于制表符所占用的空间可能是不同的，这样容易导致代码难以阅读和理解。

2.多行语句

Python中一条语句可以通过反斜杠\拆分为多行语句，括号中与多行字符串/注释中不需要添加反斜杠，可以进行换行，示例如下：

通过反斜杠换行

x = 1 + 2 + \
    3 + 4 + \
    5 + 6
s = "123" + \
    "456"

无需换行

x = [1, 2, 3,
     4, 5, 6]
y = (1, 2, 3,
     4, 5, 6)
d = {1:1, 2:2, 3:3,
     4:4, 5:5, 6:6}
s = """123
456"""

三、运算符

---

1.算术运算符

操作符	描述	复合赋值操作符
x+y	x与y之和	+=
x-y	x与y之差	-=
x*y	x与y之积	*=
x/y	x与y之商，产生结果为浮点数	/+
x//y	x与y之整数商	//=
x%y	x与y之商的余数，也称为模运算	%=
-x	x的负值	--
+x	x本身	+=
x**y	x的y次方	**=

数值运算规则：可能改变结果的数据类型，类型的改变与运算符有关，基本规则如下：

1. 整数和浮点数混合运算，输出结果是浮点数；
2. 整数之间运算，产生结果类型可能与操作符相关，运算的结果是浮点数；

符合赋值操作符

# 复合赋值运算符，它表示将变量与右侧的值相进行对应操作，并将结果赋回给该变量，示例如下
x, y = 100, 200
x += y         # 等价于 x = x + y
x += 1         # Python中没有++/--运算符，自加自减可以通过单独使用该语句实现
print(x)       # output: 301
print(x+=1)    # SyntaxError: invalid syntax => 注：此时该表达式无返回值，语法报错

数值运算规则

print(1+1.0, type(1+1.0))        # output: 2.0 <class 'float'>   (1)
print(1/2, type(1/2))            # output: 0.5 <class 'float'>   (2)
print(4/2, type(4/2))            # output: 2.0 <class 'float'>   (2)
print(4**2, type(4**2))          # output: 16 <class 'int'>      (2)
print(4**0.5, type(4**0.5))      # output: 2.0 <class 'float'>   (2)

2.位运算符

操作符	描述
&	按位与，如果对应位都是1，则对应位结果为1，否则为0，之后计算最终结果
|	按位或，如果对应位都是0，则对应位结果为0，否则为1，之后计算最终结果
^	按位异或，如果对应位值相同，则结果为0，否则为1，之后计算最终结果
~	按位取反，翻转操作数里的每一位，即0变成1，1变成0，之后计算最终结果
<<	按位左移运算符，左操作数按位右移右操作数指定的位数
>>	按位右移运算符，左操作数按位右移右操作数指定的位数

3.比较操作符

操作符	描述
==	等于
!=	不等于
<	小于
>	大于
<=	小于等于
>=	大于等于

4.逻辑(布尔)操作符

操作符	描述
and	逻辑与，当且仅当两个操作数均为真时，条件才为真
or	逻辑或，两个操作数任意一个为真时，条件则为真
not	逻辑非，用于翻转操作数的逻辑状态

第二部分 数据类型

一、概述

Python中主要数据类型包括数字类型、字符串类型、列表类型、元组类型、集合类型、字典类型 ，这些数据类型在Python中非常常用，具有不同的特点和用途。
除了这些主要的数据类型，Python还提供了其他一些内置类型，如布尔类型、空值类型等。

二、布尔类型与空值类型

---

1.布尔类型(bool)

布尔数据类型只有两种值：True和False，布尔值首字母需大写。

Python中所有数据类型在作为条件表达式时都可以转换为布尔值，当转为True时我们称为"类真"值，转为False时我们称为"类假"值。
常见"类假"值有：空值类型(None)、数字类型(0和0.0)、空字符串('')、空列表([])、空元组(())、空集合(set()) 、空字典({})，其他数据为"类真"值。

注意： 当自定义类时，通过重写类中__bool__()魔术方法可以控制该类与布尔类型的转换情况。

2.空值类型(NoneType)

None表示没有值，是NoneType数据类型的唯一值(类似C++中NULL)，首字母需大写。

三、数字类型

Python中提供3种数字类型：整数(int)、浮点数(float)和复数(complex)。

1.整数类型

Python中，整数类型可以用不同进制形式表示。
常用形式：十进制(默认)/十六进制(0x或0X开头)/八进制(0o或0O开头)/二进制(0b或0B开头)

Python(3.6以上版本)中，存储数字时系统会自动忽略_，故可以使用下划线使其更清晰易读

不同进制表示

print(63)          # output: 63
print(0x3F)        # output: 63
print(0o77)        # output: 63
print(0b111111)    # output: 63

整数的下划线表示

print(100000)      # output: 100000
print(100_000)     # output: 100000

2.浮点类型

可以表示为带有小数点的一般形式，也可以采用科学记数法表示。Python中浮点数只有十进制，且Python语言中的浮点数类型必须带有小数部分，小数部分可以是0。

由于计算机内部采用二进制表示浮点数，而大部分实数无法精确表示成有限长度的二进制小数，因此会导致精度丢失或错误的结果出现，Python中也是如此，可以通过round() 函数解决该问题。

浮点类型表示

print(1.0)      # output: 1.0
print(1.)       # output: 1.0 => 浮点数小数点后为0可以省略后面的0

精度丢失与解决

print(1.5*0.3)             # output: 0.44999999999999996
print(round(1.5*0.3,2))    # output: 0.45

3.复数类型

Python语言中，复数可以看作是二元有序实数对(a,b)，表示为：a+bj或a+bJ。a为复数的实部，b为复数的虚部。虚部通过后缀"J"或"j" 来表示。注意：当b=1时，1不能省略。
复数类型中实部和虚部都是浮点类型，对于复数z，可以用z.real和z.imag分别获得它的实数部分和虚数部分的值。

四、字符串类型(str)

Python中，字符串类型用于表示一串文本信息，表示为用双引号(或单引号)括起来的若干字符
字符串类型也是可迭代的序列类型的一种，其迭代对象依次为其包含的每个字符

1.字符串的定义

在之前其实我们已经接触与使用过字符串了，在这里再复习一下。

单行字符串

s = "这是一串单行字符串"
s = '这是一串单行字符串'
s = '这是一个错误的写法示例"  # SyntaxError => 此时程序会报错，单双引号不能混用
s = "这是'正确'的写法"       # 当字符串中存在引号时，可以嵌套使用，语法正确

多行字符串定义

multiline_string = """这是一个
   多行字符串"""  #实际存储信息：这是一个\n   多行字符串
s = "这是一个\n   多行字符串"
print(multiline_string == s) # output: True

2.可迭代对象

既然说字符串类型变量是可迭代对象，那先介绍一下可迭代对象吧~

①可迭代对象

可迭代对象一般指实现了__iter__()方法的对象，提供逐个访问可迭代对象中元素的接口，我们可以通过索引以及切片来灵活的获取他们中的值。

②索引

索引是一种按照顺序给数据结构中的元素编号的方式，通过索引我们可以快速获取元素的值

Python中索引分两种，分别是：正向索引和反向索引，如下表：

字符串	这	是	一	个	字	符	串	~
正向索引	0	1	2	3	4	5	6	7
反向索引	-8	-7	-6	-5	-4	-3	-2	-1

索引

可迭代对象名[索引]

示例

s = "这是一个字符串~"
print(s[1])           # output: 是
print(s[-7])          # output: 是
print(s[len(s)-1])    # output: ~  => 取得可迭代对象的最后一个元素

③切片

切片是在可迭代对象的基础上，按一定规则取出指定长度的元素

切片

# 语法类似range()，区别是值为索引值，参数皆为可选参数，但至少要有一个`:`
# start默认：第一个字符；stop默认：最后一个字符；step默认：1
可迭代对象名[start: stop: step]

示例

s = "这是一个字符串~"
print(s[1:4])    # output: 是一个          => 第2到4个字符
print(s[:])      # output: 这是一个字符串~  => 与s[::]结果一致
print(s[1:])     # output: 是一个字符串~    => 从第2个到末尾字符
print(s[:4])     # output: 这是一个        => 从开头字符到第四个字符
print(s[::2])    # output: 这一字串        => 从开头字符到末尾字符，步长为2
print(s[1:-1])   # output: 是一个字符串     => 两种索引可以混用
print(s[::-1])   # output: ~串符字个一是这  => 可以通过切片翻转字符串

4.字符串的格式化

Python语言中常用format()方法或f'字符串'的形式进行格式化

①format格式控制

通过在模板字符串中使用插槽{}并调用format方法可以实现格式控制

1. 当模板字符串有多个槽且未指定序号，则按槽出现的顺序分别对应.format()方法中不同参数。
2. 可以通过format()参数的序号在模板字符串槽中指定参数的使用，参数从0开始编号。

format()

"...{参数序号:格式控制标记}...".format(逗号分隔的参数)  # 模板字符串中可以有多个占位符

未指定参数序号

# 当模板字符串有多个槽且未指定序号，则按槽出现的顺序分别对应.format()方法中不同参数
"{}{}{}{}{}".format(1, "+", 1, "=", eval("1+1"))      # output: 1+1=2

指定参数序号

# 通过format()参数的序号在模板字符串槽中指定参数的使用，参数从0开始编号
"{0}{2}{1}{3}{4}".format(1, 1,"+", "=", eval("1+1"))  # output: 1+1=2

格式控制

s = "str"
num1, num2, num3,num4 = 1.2, 2.1, 200,200000000000

print("{:.>10}".format(s))                                   # output: .......str
print("{} {:.2f}".format(num1 ** num2, num1 ** num2))        # output: 1.4664951016517147 1.47
print("{:_^10}".format(num3))                                # output: ___200____
print("{:,}".format(num4))                                   # output: 200,000,000,000

详细的格式控制标记按照书写顺序如下：

②f字符串 *Python3.6

在参数不需要复杂的格式控制时，可以使用f字符串替代format更简便的进行格式控制 当参数中含有反斜杠等情况时，不能使用f字符串

f字符串

f"...{参数:格式控制标记}..."  # 直接将参数写在模板字符串中，语法更简单

示例

name='hymsk'
f'{name},你好'

5.字符串类型常用操作

s代表字符串，n代表一个常数，x代表任意变量

1. 字符串类型的基本操作符

操作符	描述
s1+s2	连接两个字符串s1与s2
s*n	复制n次字符串s
s (not) in string	如果s是string的字串，返回True(False)，否则返回False(True)
s == n	如果两个字符串的内容相同，返回True，否则返回False
x1 (not) is x2	如果两个变量的内存地址相同，返回True(False)，否则返回False(True)

2. 字符串处理函数

函数	描述
len(s)	返回字符串s的长度，也可返回其他组合数据类型的元素个数
ord(s)	返回单字符s表示的Unicode编码
str(x)	返回任意类型x所对应的字符串形式
chr(n)	返回Unicode编码n对应的单字符
hex(n)	返回整数n对应十六进制数的小写形式字符串
oct(n)	返回整数n对应八进制数的小写形式字符串

3. 字符串类型处理方法

与函数不同，字符串类型的处理方法是基于字符串类型变量进行操作的

方法	描述
s.lower()	返回字符串s的副本，全部字符小写
s.upper()	返回字符串s的副本，全部字符大写
s.title()	标题化返回字符串s的副本，首字符大写、其他字符小写
s.split(sep)	能够根据sep分隔字符串s，分割后的内容以列表类型返回。
s.count(sub)	返回字符串sub在s中出现的次数
s.replace(old, new)	返回字符串s的副本，所有old字符串被替换为new
s.center(width, fillchar)	字符串居中函数，width为宽度，fillchar为填充字符(默认为空格)
s.strip(chars)	从字符串s中去掉在其左右两侧chars中列出的字符(默认为所有空字符)
s.lstrip(chars)	从字符串s中去掉在其左侧chars中列出的字符(默认为所有空字符)
s.rstrip(chars)	从字符串s中去掉在其右侧chars中列出的字符(默认为所有空字符)
s.join(iter)	将iter变量的每一个元素中增加一个s转为字符串

4. 常见示例

操作符

s1, s2, num, s = 's1', 's2', 5, s1 + s2
print(s1 + s2)   # output: s1s2
print(s1 * 5)    # output: s1s1s1s1s1
print(s1 in s)   # output: True

字符串处理函数

num, s =  100, "this is a string"
print(len(s))     # output: 16
print(ord("s"))   # output: 115
print(str(num))   # output: 100
print(chr(num))   # output: d
print(hex(num))   # output: 0x64
print(oct(num))   # output: 0o144

字符串类型处理方法

s1, s2 = "_AbcAcdAde_", "this is a string"
print(s1.lower(), s1.upper())                          # output: _abcacdade_ _ABCACDADE_
print(s2.title())                                      # output: This Is A String
print(s2.split(" "))                                   # output: ['this', 'is', 'a', 'string']
print(" ".join(s1))                                    # output: _ A b c A c d A d e _
print(s1.rstrip("_"), s1.lstrip("_"), s1.strip("_"))   # output: _AbcAcdAde AbcAcdAde_ AbcAcdAde
print(s2.replace("string", "newString"))               # output: this is a newString

五、组合数据类型

Python中有四大组合数据类型，即列表、集合、元组、字典，他们都是可迭代类型

1.列表类型(list)

Python中的列表类型是一种有先后顺序，序列元素可以更改的序列类型

①特点

1. 列表类型用中括号[]表示，列表没有长度限制，元素类型可以不同。
2. 列表之中的元素可以是一个列表，也可以是一个元组乃至任何数据类型。
3. 列表输出是有序的，且元素在列表中可以重复出现。

②列表的索引与切片

索引与切片的详细语法见：可迭代对象

列表也是可迭代对象，自然可以进行索引与切片操作，示例如下：

索引

ls = [1, 2, 3, 4, 5, 6, 7]
print(ls[1])                   # output: 1

切片

ls = [1, 2, 3, 4, 5, 6, 7]
print(ls[1:5])                 # output: [2, 3, 4, 5]

③列表的创建与修改

1. 创建列表：使用[元素1, ...]创建列表，[]或list()创建空列表
2. 添加元素：使用append()/extend()/insert()等方法可以向列表中添加元素
3. 修改元素：使用索引配合赋值符号(=)可以对列表元素进行修改
4. 删除元素：使用相关方法或索引或切片配合保留字del对列表元素或片段进行删除

示例如下：

创建列表

a, b, c = [], list(), [1, 2, 3, 4, 5]
print(a == b)    # output: True
print(a is b)    # output: False
print(a == c)    # output: False
print(c)         # output: [1, 2, 3, 4, 5]

添加元素

a, b, c = [], list(), [1, 2, 3, 4, 5]
a.append(c)
print(a)             # output: [[1, 2, 3, 4, 5]]
b.extend(c)
print(b)             # output: [1, 2, 3, 4, 5]
c.insert(3,100)
print(c)             # output: [1, 2, 3, 100, 4, 5]

修改元素

a, b, c = [], list(), [1, 2, 3, 4, 5]
c[2]=100
print(c)    # output: [1, 2, 100, 4, 5]
c[3]=a
print(c)    # output: [1, 2, 100, [], 5]

删除元素

ls = [1, 2, 3, 4, 5] * 4
print(ls)     # output: [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
del ls[10]    # 删除索引为10的元素
print(ls)     # output: [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 2, 3, 4, 5, 1, 2, 3, 4, 5]
del ls[8:]    # 删除索引从8开始的所有元素
print(ls)     # output: [1, 2, 3, 4, 5, 1, 2, 3]
ls.remove(3)  # 删除第一个出现的3
print(ls)     # output: [1, 2, 4, 5, 1, 2, 3]

④列表类型排序

1. 用方法ls.sort()对原列表排序
2. 用方法ls.reverse()翻转原列表中的序列顺序
3. 用函数sorted(ls)返回列表排序后的结果，原列表不变

⑤序列类型中常用操作

1. 序列类型操作符

并非只有列表类型可用，基本所有组合类型皆可使用

操作符	描述
x == s	如果x与s元素与顺序相同，返回True(False)，否则返回False(True)
x (not) in s	如果x是s的子元素，返回True(False)，否则返回False(True)
x (not) is s	如果两个变量的内存地址相同，返回True(False)，否则返回False(True)
s + t	连接s和t
s * n 或 n * s	将序列s复制n次

2. 序列类型操作函数(方法)

并非只有列表类型可用，基本所有组合类型皆可使用

操作方法	描述
len(s)	序列s的元素个数（长度）
min(s)	序列s中的最小元素
max(s)	序列s中的最大元素
s.clear()	删除s中所有元素
s.index(x)	序列s中第一次出现元素x的位置
s.count(x)	序列s中出现x的总次数

3. 列表类型的操作方法

方法	描述
ls.append(x)	在列表ls最后增加一个元素x
ls.extend(l)	在列表ls后增加l列表中的所有元素
ls.insert(i, x)	在列表ls第i位置增加元素x
ls.pop(i)	取出列表ls中第i项元素，返回并删除该元素(默认最后一项)
ls.remove(x)	将列表中出现的第一个元素x删除
ls.reverse()	列表ls中元素反转
ls.copy()	生成一个新列表，复制ls中所有元素

2.元组类型(tuple)

Python中的列表类型是一种有先后顺序，序列元素不可更改的序列类型

①特点

1. Python的元组与列表类似，不同之处在于元组的元素不能修改。
2. 元组使用小括号()表示。
3. 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

②元组的索引与切片

索引与切片的详细语法见：可迭代对象

元组也是可迭代对象，虽不能修改元素，但可以切片生成新的元组，示例如下：

3.集合类型(set)

Python中的集合类型与数学中的集合概念一致，即包含若干不重复的数据项的无序组合。

①特点

1. Python集合类型用{}表示，它没有索引和位置的概念，集合中元素可以动态增加或删除。
2. 集合类型不可重复且无序(Python3.7后按插入顺序排列)，不可索引与切片
3. 创建空集合需要使用set()，否则默认创建的是字典类型对象。

②集合运算操作符

操作符的运算	描述（S和T是两个集合）	数学含义
S & T	返回一个新集合包括同时在集合S和T中的元素	交集
S | T	返回一个新集合包括集合S和T中所有元素	并集
S - T	返回一个新集合包括在集合S中但不在集合T中的元素	差集
S ^ T	返回一个新集合包括集合S和T中非共同元素	补集

③集合类型中常用的操作函数或方法

函数或方法	描述（S是一个集合）
S.add(x)	如果数据项x不在集合S中，将x增加到s
S.remove(x)	如果x在集合S中，移除该元素；不在产生KeyError异常
S.clear()	移除S中所有数据项
len(S)	返回集合S元素个数
x in S	如果x是S的元素，返回True，否则返回False
x not in S	如果x不是S的元素，返回True，否则返回False

4.字典类型(dict)

Python中的字典类型是一种无先后顺序，存储键值对元素的可以更改的序列类型

①特点

1. 字典类型也用{}表示，其每个元素是一个键值对。
2. 字典类型中键不可重复且无序(Python3.7后按插入顺序排列)，字典不可切片但可使用索引

②字典的创建与修改

字典类型键值对中的键是值的索引，可以直接利用键值对关系索引元素，但不能使用切片。

1. 创建字典：使用{key:value, ...}或dict()可以创建字典
2. 添加/修改键值对：利用索引和=配合，可以向字典中增加新元素或修改旧元素。
3. 删除键值对：使用保留字del指定键名可以删除对应键值对

③字典类型中常用操作

1. 操作函数

函数	描述
len(d)	字典d的元素个数（长度）
min(d)	字典d中键的最小值
max(d)	字典d中键的最大值

2. 操作方法

方法	描述
d.keys()	返回所有的键信息
d.values()	返回所有的值信息
d.items()	返回所有的键值对
d.get(key, default)	键存在则返回相应值，否则返回默认值
d.pop(key, default)	键存在则返回相应值，同时删除键值对，否则返回默认值
d.popitem()	随机从字典中取出一个键值对，以元组(key, value)形式返回
d.clear()	删除所有的键值对