1 变量
1.1 变量的定义
变量是可以赋给值的标签，也可以说变量指向特定的值。在Python中，每个变量使用前都必须赋值，变量在赋值以后才会被创建。等号（
=
=
=）用来给变量赋值：
变量名 = 值
变量名1, 变量名2... = 值1, 值2...
变量赋值（创建）之后就可以被直接使用了。在程序中可以随时修改变量的值，而Python将始终记录变量的最新值（变量名只有在第一次出现时才是定义变量；如果再次出现，不是定义变量，而是直接使用之前定义过的变量）。
1.2 变量的命名规则
1）命名规则
- 变量名只能包含字母、数字和下划线；
- 不能以数字开头；
- 不要将Python关键字和内置函数名用作变量名。
# 关键字
In [1]: import keyword
In [2]: print(keyword.kwlist)
Out[2]: ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
# 内置函数
abs(), all(), any(), ...
（Python中的变量名是区分大小写的，一般应使用小写的变量名。大写字母在变量名中有特殊的含义：①Python没有内置的常量类型，但程序员会使用全大写来指出应将某个变量视为常量；②驼峰命名法使用到大写字母。）
2）命名方法
当变量名需要由两个或多个单词组成时，可以按照以下方式命名：
【常用】：每个单词都使用小写字母，单词之间使用下划线连接。例如：first_name
小驼峰式命名法：第一个单词以小写字母开始，后续单词的首字母大写。例如：firstName
大驼峰式命名法：每个单词的首字母都大写。例如：FirstName
1.3 变量的类型(type( ))
在Python中定义变量是不需要指定类型的，解释器会根据赋值自动推导出变量中存储数据的类型。数据类型可以分为数字型和非数字型：
- 数字型：整型(int)、浮点型(float)、复数型(complex)、布尔型(bool)
- 非数字型：字符串(str)、列表(list)、元组(tuple)、集合(set)、字典(dict)
1.4 变量的输入与输出
1）输入input
所谓输入，就是用代码获取用户通过键盘键入的信息。在Python中可以使用 input 函数让程序暂停运行，等待用户输入一些文本，输入的任何内容Python都认为是一个字符串（可使用 int( ) 函数来获取数值输入）：
字符串变量名 = input("提示信息：")
例如：
In [1]: prompt = "If you tell us who you are, we can personalize the messages you see."
In [2]: prompt += "\nWhat is your first name? "
In [3]: name = input(prompt)
In [4]: print("\nHello, " + name + "!")
Out[4]: If you tell us who you are, we can personalize the messages you see.
What is your first name? Ada
Hello, Ada!
2）格式化输出
在Python中可以使用 input 函数将信息输出到控制台，但如果希望输出文字信息的同时一起输出数据，就需要使用到（①格式化操作符%、②f字符串、③format( )）。下边给出常用的第一种方法，即格式化操作符%。%被称为格式化操作符，专门用于处理字符串中的格式，包含%的字符串被称为格式化字符串。语法格式为：
print("格式化字符串" % 变量1)
print("格式化字符串" % (变量1, 变量2...))
| 格式化字符串 | 含义 |
|---|---|
| %s | 字符串 |
| %d / %s | 返回要格式化对象的十进制表示。%nd：其中n为整数，表示用空格填充；%0nd：表示用0填充 |
| %f | 返回要格式化对象的浮点数表示。%m.nf：其中m, n为整数，m 是显示的最小总宽度，n 是小数点后的位数 |
| %% | 输出% |
（参考链接：Python格式化输出、Python格式化输出）
在默认情况下，print 函数输出内容之后，会自动在内容末尾增加换行；如果不希望末尾增加换行，可以在 print 函数输出内容的后面增加 end=’’ "；引号之间可以指定 print 函数输出内容之后，希望继续显示的内容。例如：
In [1]: print('What is your first name?', end='')
In [2]: print('Ada')
Out[2]: What is your first name?Ada
2 简单数据类型
2.1 数
1）数字型
整型(int)：整数就是没有小数部分的数，Python中的整数包括正整数、零和负整数。有些强类型语言会提供多种整数类型，每种类型的长度不同，能容纳的整数的大小也不同，开发者要根据实际数字的大小选用不同的类型。例如C语言提供了short、int、long、long long四种类型的整数，它们的长度依次递增，初学者在选择整数类型时往往比较迷惑，有时候还会导致数值溢出。而Python则不同，它的整数不分类型，或者说它只有一种类型的整数。
浮点型(float)：Python中的小数有两种书写形式，①十进制形式，例如34.6、346.0；②指数形式，例如3.46E5 = 3.46×10^5。
复数型(complex)：复数由实部（Re）和虚部（Im）构成，在Python中，复数的虚部以 j 或者 J 作为后缀，例如a + bj。
布尔型(bool)：Python提供了bool类型来表示真或假。例如5 > 3比较算式，这个是正确的，在程序世界里称之为真，Python使用 True 来代表；4 > 20比较算式，这个是错误的，在程序世界里称之为假，Python 使用 False 来代表。值得一提的是，布尔类型可以当做整数来对待，即 True 相当于整数值 1，False 相当于整数值 0。
2）注意事项
- 书写很大的数时，可使用下划线将其中的数字分组以使其更加清晰易读，例如a = 14_000_000_000。将数字分组时，即便不是将每三位分成一组也不会影响最终的值，在Python看来，1000和1_000、10_00没什么不同。
- 将任意两个数相除时，结果总是浮点数，即便这两个数都是整数且能够整除。
- 无论是那种运算，只要有操作数是浮点数，Python默认得到的总是浮点数，即使结果原本为整数也是如此。
2.2 运算符
参考链接：数学符号表
1）算数运算符
| 算数运算符 | 描述 | 实例 |
|---|---|---|
| + | 两个数相加，或是字符串合并（拼接） | 10 + 20 = 30 |
| - | 两个数相减 | 10 - 20 = -10 |
| * | 两个数相乘，或是返回一个重复指定次数的字符串 | 10 * 20 = 200 |
| / | 两个数相除，结果为浮点数 | 10 / 20 = 0.5 |
| // | 取整除，返回商的整数部分（向下取整） | 9 // 2 = 4 |
| ** | 幂运算，返回乘方结果 | 9 ** 2 = 81 |
| % | 取模，返回两个数相除的余数 | 9 % 2 = 1 |
2）比较（关系）运算符
| 比较运算符 | 描述 |
|---|---|
| == | 检查两个操作数的值是否 相等；如果是，则条件成立，返回 True，否则返回 False |
| != | 检查两个操作数的值是否 不相等；如果是，则条件成立，返回 True，否则返回 False |
| > | 检查左操作数的值是否 大于 右操作数的值；如果是，则条件成立，返回 True，否则返回 False |
| < | 检查左操作数的值是否 小于 右操作数的值；如果是，则条件成立，返回 True，否则返回 False |
| >= | 检查左操作数的值是否 大于或等于 右操作数的值；如果是，则条件成立，返回 True，否则返回 False |
| <= | 检查左操作数的值是否 小于或等于 右操作数的值；如果是，则条件成立，返回 True，否则返回 False |
3）赋值运算符
| 赋值运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单赋值运算符 | c = a + b，将a + b的运算结果赋值给c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
| **= | 幂运算赋值运算符 | c **= a 等效于 c = c ** a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
4）逻辑运算符（一般和关系运算符结合使用）
| 逻辑运算符 | 描述 | 实例 |
|---|---|---|
| and | 逻辑与运算 | a and b：当 a 和 b 两个表达式都为True时，a and b 的结果才为True，否则返回False |
| or | 逻辑或运算 | a or b：当 a 和 b 两个表达式都为False时，a or b 的结果才为False，否则返回True |
| not | 逻辑非运算 | not a：如果 a 为True，那么 not a 的结果为False；如果 a 为False，那么 not a 的结果为True |
关于逻辑运算符的说明：
- Python逻辑运算符可以用来操作任何类型的表达式，不管表达式是不是布尔类型；同时逻辑运算的结果也不一定是布尔类型，而可以是任意类型的。
例如：
In [1]: print('Ada Lovelace' and 'Python') # return Python
- 在Python中，and 和 or 不一定会计算右边表达式的值，有时候只计算左边表达式的值就能得到最终结果。另外，and 和 or 运算符会将其中一个表达式的值作为最终结果，而不是将 True 或者 False 作为最终结果：
- 对于 and 运算符，两边的值都为真时最终结果才为真，但是只要其中有一个值为假，那么最终结果就是假，所以Python按照下面的规则执行 and 运算：
如果左边表达式的值为假，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是假，此时 and 会把左边表达式的值作为最终结果。
如果左边表达式的值为真，那么最终值是不能确定的，and 会继续计算右边表达式的值，并将右边表达式的值作为最终结果。 - 对于 or 运算符，情况是类似的，两边的值都为假时最终结果才为假，但是只要其中有一个值为真，那么最终结果就是真，所以Python按照下面的规则执行 or 运算：
如果左边表达式的值为真，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是真，此时 or 会把左边表达式的值作为最终结果。
如果左边表达式的值为假，那么最终值是不能确定的，or 会继续计算右边表达式的值，并将右边表达式的值作为最终结果。
例如：
In [1]: print(0 and 20) # return 0
In [2]: print(10 and 20) # return 20
In [3]: print(10 or 20) # return 10
In [4]: print(0 or 20) # return 20
5）位运算符（二进制）
| 位运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位“与”运算符：参与运算的两个操作数，如果其二进制相应位都为 1，则结果为 1，否则为 0 | 60 & 13 = 12 |
| | | 按位“或”运算符：参与运算的两个操作数，如果其二进制相应位有一个为 1 时，则结果为 1，否则为 0 | 60 | 13 = 61 |
| ^ | 按位“异或”运算符：参与运算的两个操作数，如果其二进制相应位相异时，则结果为 1，否则为 0 | 60 ^ 13 = 49 |
| ~ | 按位“取反”运算符：对操作数的每个二进制位取反。如对 a 按位取反，则得到的结果为 -(a+1) | ~60 = -61 |
| << | “左移动”运算符：操作数的各二进制位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃， 低位补 0 | 60 << 2 = 240 |
| >> | “右移动”运算符：操作数的各二进制位全部右移若干位，由“>>”右边的数指定移动的位数，高位丢弃， 低位补 0 | 60 >> 2 = 15 |
例如：
In [1]: a = 60 # 60 = 0011 1100
In [2]: b = 13 # 13 = 0000 1101
In [3]: print(a & b) # 12 = 0000 1100
In [4]: print(a | b) # 61 = 0011 1101
In [5]: print(a ^ b) # 49 = 0011 0001
In [6]: print(~a) # -61 = 1100 0011
In [7]: print(a << 2) # 240 = 1111 0000
In [8]: print(a >> 2) # 15 = 0000 1111
6）成员运算符
| 成员运算符 | 描述 |
|---|---|
| in | 当在指定的序列中找到值时返回 True，否则返回 False |
| not in | 当在指定的序列中没有找到值时返回 True，否则返回 False |
7）身份运算符
| 身份运算符 | 描述 |
|---|---|
| is | 判断两个标识符是否引用自同一个对象，若引用的是同一个对象则返回 True，否则返回 False |
| is not | 判断两个标识符是不是引用自不同对象，若引用的不是同一个对象则返回 True，否则返回 False |
is 与 == 的区别：is 用于判断两个变量引用对象是否为同一个(同一块内存空间)， == 用于判断引用变量的值是否相等。
In [1]: a = [1, 2, 3]
In [2]: b = a[:]
In [3]: print(a == b) # return True
In [4]: print(a is b) # return False
8）运算符优先级
| 运算符 | 描述 |
|---|---|
| ** | 幂运算 |
| ~ | 按位“取反”运算符 |
| *、/、%、// | 乘、除、取模、取整除 |
| +、- | 加、减 |
| >>、<< | 右移、左移 |
| & | 按位“与” |
| ^、| | 按位“异或”、按位“或” |
| <=、<、>、>= | 比较运算符 |
| ==、!= | 等于、不等于 |
| =、%=、/=、//=、-=、+=、*=、**= | 赋值运算符 |
| is、is not | 身份运算符 |
| in、not in | 成员运算符 |
| and、or、not | 逻辑运算符 |
2.3 字符串
字符串(str)：字符串就是一系列字符。在Python中，用引号括起来的都是字符串，其中的引号可以是单引号也可以是双引号（这种灵活性让你能够在字符串中包括引号和撇号）。链接：《Python基础知识-2高级数据类型A》
# 字符串
'I told my friend, "Python is my favorite language!"'
"The language 'Python' is named after Monty Python, not the snake."
"One of Python's strengths is its diverse and supportive community."
1）修改字符串大小写
In [1]: name = "Ada lovelace"
In [2]: print(name.title()) # 方法title()以首字母大写的方式显示每个单词
Out[2]: 'Ada Lovelace'
In [3]: print(name.upper()) # 全部大写
Out[3]: 'ADA LOVELACE'
In [4]: print(name.lower()) # 全部小写
Out[4]: 'ada lovelace'
2）合并（拼接）字符串
# 字符串变量之间使用 + 拼接
In [1]: first_name = "ada"
In [2]: last_name = "lovelace"
In [3]: full_name = first_name + " " + last_name
In [4]: message = "Hello, " + full_name.title() + "!"
In [5]: print(message)
Out[5]: 'Hello, Ada Lovelace!'
# 使用 f 字符串
In [1]: first_name = "ada"
In [2]: last_name = "lovelace"
In [3]: full_name = f"{first_name} {last_name}"
In [4]: message = f"Hello, {full_name.title()}!"
In [5]: print(message)
Out[5]: 'Hello, Ada Lovelace!'
# 字符串变量和整数之间使用 * 重复拼接
In [1]: message = "Ada Lovelace " * 2
In [2]: print(message)
Out[2]: 'Ada Lovelace Ada Lovelace '
3）制表符和换行符（转义字符）
# 制表符 \t
In [1]: print("Python")
Out[1]: 'Python'
In [2]: print("\tPython")
Out[2]: ' Python'
# 换行符 \n
In [1]: print("Languages:\nPython\nC\nJavaScript")
Out[1]: 'Languages:
Python
C
JavaScript'
4）删除空格
# 删除字符串两边的空格 strip()
In [1]: favorite_language = ' python '
In [2]: print(favorite_language.strip())
Out[2]: 'python'
# 删除字符串开头的空格 lstrip()
In [1]: print(favorite_language.lstrip())
Out[1]: 'python '
# 删除字符串末尾的空格 rstrip()
In [1]: print(favorite_language.rstrip())
Out[1]: ' python'
# 删除字符串中的空格 replace()
In [1]: favorite_language = ' pyt ho n '
In [2]: print(favorite_language.replace(" ", ""))
Out[2]: 'python'
（参考链接：字符串方法）
2.4 类型转换
| 函数 | 描述 |
|---|---|
| int(x) | 将 x 转换成整数类型 |
| float(x) | 将 x 转换成浮点数类型 |
| complex(a, b) | 创建一个复数(a + bj) |
| str(x) | 将 x 转换为字符串 |
| repr(x) | 将 x 转换为表达式字符串 |
| eval(str) | 计算在字符串中的有效 Python 表达式，并返回一个对象 |
| chr(x) | 将整数 x 转换成ASCII码字符 |
| ord(x) | 将ASCII码字符 x 转换成整数 |
| hex(x) | 将一个整数 x 转换为一个十六进制字符串 |
| oct(x) | 将一个整数 x 转换为一个八进制字符串 |
| bin(x) | 将一个整数 x 转换为一个二进制字符串 |
例如：
print(int('29')) # return 29
print(float('2.9')) # return 2.9
print(complex(2, 9)) # return (2+9j)
print(str(29)) # return '29'
print(repr(29)) # return '29'
print(eval('2+9')) # return 11
print(chr(48)) # return 0
print(ord('0')) # return 48
ASCII码对照表：
