【Python】基础总结

输入

input("提示性信息")

如：
input("请输入数字")

评估函数

因为 Python 没有特别人为规定数据类型，数据类型是由计算机进行判定，所以我们 input() 输入的数据均默认作为字符串处理，而如果要输入一些数字，着需要 eval() 评估函数对字符串进行评估，化为语句（数字）。

输出

print(...)
默认空一行，如果想不空行，则
print(...., end = "")

数字类型

整数类型

特性：

• 可正可负，没有取值范围限制
• pow(x, y) 函数：计算\(x^y\)，想算多大算多大

进制：

• 十进制：1010，99，-217
• 二进制：以 0b 或 0B 开头：0b010，-0B101
• 八进制：以 0o 或 0O 开头：0o123，-0O456
• 十六进制：以 0x 或 0X 开头：0x9a，-0X89

浮点数类型

特性：

• 带有小数点及小数的数字
• 浮点数取值范围和小数精度都存在限制，但常规计算可忽略
• 取值范围数量级约为\(-10^{307}\)至\(10^{308}\)，精度数量级\(10^{-16}\)
• 浮点数间运算存在不确定尾数，不是 bug

不确定尾数

浮点数间运算存在不确定尾数，不是 bug
如：0.1+0.3 → 0.4
0.1+0.2 → 0.30000000000000004

这是由于在计算机中一切数据都是化为二进制进行存储的，而有的浮点数并不能完全化为相等的二进制数，只能无限趋近于二进制数。
如：0.1 →

• 二进制表示：0.00011001100110011001100110011001100...等 53位二进制表示小数部分，约 \(10^{-16}\)

• 十进制表示：0.10000000000000000555111512312578270...

四舍五入

解决方法：

• 0.1+0.2 == 0.3 → False
• round(0.1+0.2, 1) == 0.3 → True

四舍五入：

• round(x, d)：对 x 四舍五入，d 是小数截取位数。
• 浮点数间运算与比较用 round() 函数辅助
• 不确定尾数一般发生在 \(10^{-16}\) 左右，round() 十分有效

科学计数法

• 使用字母 e 或 E 作为幂的符号，以 10 为基数，格式如下：
  <a>e<b> 表示 \(a*10^b\)

复数类型

例如：z = 1.23e-4 + 5.6e+89j
z.real 获得实部，z.imag 获得虚部

数值运算操作符

数字类型的关系

三种类型存在一种逐渐“扩展”或“变宽”的关系：
整数 → 浮点数 → 复数

数值运算函数

字符串类型

字符串类型的表示

特点：

• 字符串由一对单引号或一对双引号表示

• 字符串是字符的有序序列，可以对其中的字符进行索引

字符串有 2 类共 4 种表示方法：

• 由一对单引号或双引号表示，仅表示单行字符串

• 由一对三单引号或三双引号表示，课表示多行字符串

扩展：

• 如果希望在字符串中包含双引号或单引号呢？
  '这里有个双引号(")' 或者 "这里有个单引号(')"
• 如果希望在字符串中既包括单引号又包括双引号呢？
  '''这里既有单引号(')又有双引号(")'''

字符串的序号

字符串的使用

使用[]获取字符串中一个或多个字符

• 索引：返回字符串中单个字符。[M]

• 切片：返回字符串中一段字符子串。[M:N]

字符串切片高级用法

使用[M:N:K]根据步长对字符串切片

• [M:N]，M 缺失表示至开头，N 缺失表示至结尾

• [M:N:K]，根据步长 K 对字符串切片

字符串操作符

字符串处理函数

字符串处理方法

字符串类型的格式化

• 字符串格式化使用.format()方法，用法如下：
  .format()

槽内部对格式化的配置方式

{:}

填充、对齐、宽度这三个一组，例如：
"{0:=^20}".format("PYTHON")
→ '=======PYTHON======='
"{0:*>20}".format("BIT")
→ '*****************BIT'
"{:10}".format("BIT")
'BIT '

剩下的三个一组，例如：
"{0:,.2f}".format(12345.6789)
→ '12,345.68'
"{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}x".format(425)
→ '110101001,Σ,425,651,1a9,1A9'
"{0:e},{0:E},{0:f},{0:%}".format(3.14)
'3.140000e+00,3.140000E+00,3.140000,314.000000%'

异常处理

try:
    # 执行1
    <语句块1>
except [<异常类型>]:
    # 如果出现异常执行2
    <语句块2>
[else:]
    # 否则，不发生异常执行3
    <语句块3>
[finally:]
    # 最后执行4，一定执行
    <语句块4>

使用 raise 语句抛出一个指定的异常。
raise [Exception [, args [, traceback]]]

分支结构

二分支结构

紧凑形式：适用于简单表达式的二分支结构
<表达式1> if <条件> else <表达式2>

例如：

guess = eval(input())
print("猜{}了".format("对" if guess==99 else "错"))

多分支结构

if
elif
else

循环结构

遍历循环

for <循环变量> in <遍历结构> :
    <语句块> 

• 从遍历结构中逐一提取元素，放在循环变量中
• 由保留字for和in组成，完整遍历所有元素后结束
• 每次循环，所获得元素放入循环变量，并执行一次语句块

计数循环（N次）

for i in range(N) :
    <语句块> 

• 遍历由range()函数产生的数字序列，产生循环

例如：

for i in range(5):
    print("Hello:",i)

运行结果：

Hello: 0
Hello: 1
Hello: 2
Hello: 3
Hello: 4

计数循环（特定次）

for i in range(M,N,K) :
    <语句块> 

• 遍历由range()函数产生的数字序列，产生循环

例如：

for i in range(1,6,2):
    print("Hello:",i)

运行结果：

Hello: 1
Hello: 3
Hello: 5

字符串遍历循环

for c in s :
    <语句块> 

• s是字符串，遍历字符串每个字符，产生循环

例如：

for c in "Python123":
print(c, end=",")

运行结果：

P,y,t,h,o,n,1,2,3,

列表遍历循环

for item in ls :
    <语句块> 

• ls是一个列表，遍历其每个元素，产生循环

例如：

for item in [123, "PY", 456] :
print(item, end=",")

运行结果：

123,PY,456,

文件遍历循环

for line in fi :
    <语句块> 

• fi是一个文件标识符，遍历其每行，产生循环

例如：

for line in fi :
print(line)

运行结果：

优美胜于丑陋
明了胜于隐晦
简洁胜于复杂

无限循环

由条件控制的循环运行方式

while <条件> :
    <语句块> 

• 反复执行语句块，直到条件不满足时结束

例如：

a = 3
while a > 0 :
    a = a - 1
    print(a)

运行结果：

2
1
0

扩展

for <变量> in <遍历结构> :
    <语句块1>
else :
    <语句块2>

while <条件> :
    <语句块1>
else :
    <语句块2>

• 当循环没有被break语句退出时，执行else语句块
• else语句块作为"正常"完成循环的奖励
• 这里else的用法与异常处理中else用法相似

例如：

for c in "PYTHON" :
    if c == "T" :
        continue
    print(c, end="")
else:
    print("正常退出")

运行结果：

PYHON正常退出

例如：

for c in "PYTHON" :
    if c == "T" :
        break
    print(c, end="")
else:
    print("正常退出")

运行结果：

PY

函数

• 函数定义时可以为某些参数指定默认值，构成可选参数
• 函数定义时可以设计可变数量参数，即 不确定参数总数量
• 函数调用时，参数可以按照位置或名称方式传递，如 f(1, 2) → f(m=1, n=2)
• 函数可以返回 0 个或多个结果（元组类型）

def <函数名>(<非可选参数> [,<可选参数>, <可变参数>]) :
    <函数体>
    return <返回值>

可选参数例如：

def f(m, n=1)
    return m+n

print(f(1))

运行结果：

2

可变参数例如：

def f(*b):
    sum = 0
    for item in b:
        sum += item
    return sum

print(f(1,2,3,4,5))

运行结果：

15

在函数定义中，经常会碰到 *args(arguments) 和作为参数 **kwargs(keyword arguments)。
（事实上在函数中，和才是必要的，args 和 kwargs 可以用其他名称代替）
*args 是指不定数量的非键值对参数。
**kwargs 是指不定数量的键值对参数。

*args 作为作为元组匹配没有指定参数名的参数。而 **kwargs 作为字典，匹配指定了参数名的参数。
*args 必须位于 **kwargs 之前。

*args(*通常紧跟一个标识符，你会看到a或者args都是标识符)是python用于接收或者传递任意基于位置的参数的语法。当你接收到一个用这种语法描叙参数时（比如你在函数def语句中对函数签名使用了星号语法），python会将此标识符绑定到一个元祖，该元祖包含了所有基于位置的隐士的接收到的参数。当你用这种语法传递参数时，标识符可以被绑定到任何可迭代对象（事实上，它也可以是人和表达式，并不必须是一个标识符），只要这个表达式的结果是一个可迭代的对象就行。

**kwds(标识符可以是任意的，通常k或者kwds表示)是python用于接收或者传递任意基于位置的参数的语法。（python有时候会将命名参数称为关键字参数，他们其实并不是关键字--只是用他们来给关键字命名，比如pass,for或者yield，还有很多，不幸的是，这种让人疑惑的术语目前仍是这门语言极其文化根深蒂固的一个组成部分。）当你接收到用这种语法描叙的一个参数时（比如你在函数的def语句中对函数签名使用了双星号语法）python会将标识符绑定到一个字典，该字典包含了所有接收到的隐士的命名参数。当你用这种语法传递参数时，标识符只能被绑定到字典（我ID号I它也可以是表达式，不一定是一个标识符，只要这个表达式的结果是一个字典即可）。

当你在定义或调用一个函数的时候，必须确保a和k在其他所有参数之后。如果这两者同时出现，要将k放在a之后。

局部变量和全局变量

• 基本数据类型，无论是否重名，局部变量与全局变量不同
• 可以通过 global 保留字在函数内部声明全局变量

• 组合数据类型，如果局部变量未真实创建，则是全局变量

lambda 函数

lambda函数返回函数名作为结果

• lambda函数是一种匿名函数，即没有名字的函数
• 使用lambda保留字定义，函数名是返回结果
• lambda函数用于定义简单的、能够在一行内表示的函数

<函数名> = lambda <参数>: <表达式>

def <函数名>(<参数>) :
    <函数体>
    return <返回值>

例如：

f = lambda : "lambda函数"
print(f())

运行结果：

lambda函数

谨慎使用lambda函数

• lambda函数主要用作一些特定函数或方法的参数
• lambda函数有一些固定使用方式，建议逐步掌握
• 一般情况，建议使用def定义的普通函数