「Python 基础」基础语法与高级特性

1. 基础语法

• ”#“ 开头的是注释
• 每一行是一个语句，当语句以冒号 “:” 结尾时，缩进的语句被视为代码块

好处：强迫代码格式化，强迫少用缩进
坏处：“复制-粘贴”失效，无法自动格式化

条件判断

if x:
    print(True)

只要 x 是非零，非空白字符串，非空 list，非 None 等空白或空值，就判断为 True，否则为 False

循环

• for x in …：把每个元素代入变量 x
• range(x)：可以生成一个整数序列，从 0 开始，遇 x 停止
• list(range(x))：可以得到[0,1,2,3,…x-1]
• while n>0：满足 n>0 就不断循环
• break：提前结束当前整个循环
• continue：跳出当前这次循环

数据类型

类型	精度	大小	说明
整型	精确	无大小限制	十六进制，以 0x 为前缀，由 0-9，a-f 表示，允许数字中间以 ‘_’ 分隔，入 10_000_000(同 10000000)，0xa1b2_c3d4(同 0xa1b2c3d4)
浮点型	四舍五入	无大小限制	inf(无限大)，科学计数法，把 10 用 e 替代，1.23e9
字符串	-	-	r’’ 表示’‘内部的字符串默认不转义，’‘’…‘’’ 的格式表示多行内容
布尔	-	-	可以用 and, or, not 运算
空值	-	-	None

整数除法

运算符	说明
/	结果是精确的商，永远是浮点数
//	结果是商的整数部分，永远是整数
%	结果是余数部分，永远是整数

变量

必须是大小写英文，数字和 ‘_’ 组合，并且不以数字开头；
可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量

变量在计算机内存中的表示，如下

a = 'ABC'

Python 解释器干了两件事情：

1. 在内存中创建了一个’ABC’的字符串；
2. 在内存中创建了一个名为 a 的变量，并把它指向’ABC’。

变量本身类型不变的计算机编程语言为动态语言

常量

常量就是不能变的变量，Python 通常用全部大写的变量名表示常量，Python 不强制常量无法修改

字符编码

• 8 比特(bit)为一个字节(byte)，最大表示 2⁸-1 =255
• ASCII 码有 127 个字符
• Unicode 把所有语言都统一到一套编码里
• UTF-8 把 Unicode 字符根据不同的数字大小编码成 1-6 个字节（常用英文字符编码成 1 个字节，汉字通常是 3 个字节，很生僻字才编码成 4-6 字节）
• ASCII 可以看作 UTF-8 的一部分
• 计算机内存统一使用 Unicode，当需要保存到磁盘或传输时，转为通用 UTF-8s

字符串

• ord() 可以获取字符的整数表示
• chr() 把编码转成对应的字符
• len() 参数是 str 时表示字符数，参数是 list 时表示元素个数，参数是 bytes 时表示字节数

编码与解码

encode() 将 str 编码成指定的 bytes

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'

decode() 将指定 bytes 解码为 str

# errors='ignore' 忽略错误的字节
>>> b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')
'中'

格式化

占位符

占位符	替换内容	说明
%d	整数	用空位或 0 补长，'%2d-%02d' % (3, 1) => 3-01
%f	浮点数	保留小数位数，'%.2f' % 3.1415926 => 3.14
%s	字符串
%x	十六进制整数

format() 用传入的参数依次替换字符串内的占位符 {0}, {1}...

>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
'Hello, 小明, 成绩提升了 17.1%'

f-string 字符串包含 {xxx}，就会以 xxx 变量来替换

>>> r = 2.5
>>> s = 3.14 * r ** 2
>>> print(f'The area of a circle with radius {r} is {s:.2f}')
The area of a circle with radius 2.5 is 19.62

list

一种有序的集合，可以随时添加或删除其中的元素，元素的类型可以不同

方法	说明
[]	索引，listA[0]：获取第一个元素；listA[-1]：获取最后一个元素；listA[1] = ‘C’：把第二个元素替换为 ‘C’
append	追加，listA.append(‘A’)：在末尾最佳一个 ‘A’
insert	listA.insert(1, ‘B’)：在第一个元素后面插入一个 ‘B’
pop	listA.pop()：删除末尾；pop(1)：删除第二个元素

赋值语句不能与这些方法同用

>>> listB = listA.append('A')
>>> print(listB)
None

tuple

另一种有序集合，一旦初始化不能修改（指向不变：变量所指向的实例不能修改）

• 定义空元组，t = ()
• 定义单元素元组，t = (1,)
• 要保证元组内容不可变，必须保证元组的每个元素本身不可变

dict

python 内置字典，在其他语言也叫 map，使用键-值存储，具有极快的查找速度，不会随着大小的变化而变慢，相比 list 占用大量内存，以空间换时间

方法	说明
in	'T' in d 判断’T’是否存在于 d.keys
get	d.get('T') 获取 key 为 ‘T’ 的值； d.get('T', -1) 获取 key 为 ‘T’ 的值，如不存在取默认值 -1
pop	d.pop('B') 删除 key 为’B’ 的键值对

dict 的 key 必须是不可变对象，如：字符串，整数等，否则抛异常（TypeError: unhashable type）

set

与 dict 类似，也是一组 key 的集合，但不存储 value，key 不能重复，数学意义上的无序和无重复元素的集合

创建

>>> s = set([1,2,2,3,3])
>>> s
{1, 2, 3}

添加

>>> s.add(4)
>>> s
{1, 2, 3, 4}

删除

>>> s.remove(4)
>>> s
{1, 2, 3}

并交

>>> ss = set([2,3,4])
>>> s&ss
{2, 3}
>>> s|ss
{1, 2, 3, 4}

不可变对象

>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'

tuple 也是不可变对象

• (1, 2, 3) 可以作为 dict 和 set 的 key
• (1, 2, [1, 2]) 不可作为 dcit 和 set 的 key，TypeError: unhashable type

2. 高级特性

在 Python 中，代码越少越好，越简单越好，开发效率越高越好；

切片

slice

[m:n:p]

m 开始位，为 0 时可以不写，为负数时表示倒数第几个
n 结束位（不含），为最大长度时可以不写，为负数时表示倒数第几个
p 步长，从开始位取第一个元素，每 p 位取一个元素

slice 实现 trim()

def trim(s):
    if s == '':
        return s
    if s[0] == ' ':
        return trim(s[1:])
    if s[-1] == ' ':
        return trim(s[:-1])
    return s

迭代

Iteration

遍历一个 list、tuple、dict、set、str 或其他可迭代对象，就叫迭代

dict

dict 不是顺序排列，迭代结果无序

keys: 迭代 key，for i in d.keys(): 等同于 for i in d:
values: 迭代 value for v in d.values():
items：同时迭代 key 和 value for key, value in d.items():

判断是否可迭代对象

# `str` 也是可迭代对象
>>> from collections import Iterable
>>> isinstance('abc', Iterable)
True

同时迭代索引和元素

# 在 for 循环中同时引用两个变量
>>> for index, value in enumerate(['a', 'b', 'c']):
...     print(index, value)
...
0 a
1 b
2 c

列表生产式

List Comprehensions

把要生成的元素放在前面，后面跟 for 循环，就可以创建一个 list，这就是列表生成式

# 双重循环
# if 在 for 后面，if 是筛选条件，不能加 else
>>> [m + n for m in L1 for n in L2 if isinstance(m, str) and isinstance(n, str)]
# if 在 for 前面，for 前面是一个完整表达式，必须加 else 以计算出一个结果
>>> [x if x % 2 == 0 else -x for x in range(1, 11)]
>>> list(range(2, 10, 2)) # 参数位同切片

生成器

Generator

可以按照某种算法推算出列表后续的元素，而不用创建完整的列表，一边循环一边计算的机制，就叫生成器

创建方式

1. 把列表生成式的 [] 换成 ()
2. 函数的 return 换成 yield（包含 yield 的函数即生成器）

调用方式
调用 genertor 时，会生成一个 generator 对象 g

1. next(g)
2. for n in g

生成器与函数的区别

	说明
function	顺序执行，遇到 return 或最后一行返回，直接返回结果
generator	调用 next() 时执行，遇到 yield 返回，再次执行 next() 时从上次返回的 yield 继续执行，“调用”实际返回一个 generator 对象

generator 调用 next()

# 杨辉三角
def triangles():
    L = [1]
    while True:
        yield L
        L.append(0)
        L = [L[i - 1] + L[i] for i in range(len(L))]

迭代器

Iterator

	说明
Iterable	可迭代对象，如 list、tuple、dict、set、str 等，以及 generator
Iterator	可以被 next() 函数调用并不断返回下一个值的对象，没有下一个值时抛出 StopIteration 错误，表示的是一个数据流，其计算是惰性的，并不能提前知道长度

判断是否迭代器

>>> from collections.abc import Iterator
>>> isinstance((x for x in range(10))， Iterator)
True

iter()
将 Iterable对象变成 Iterator

>>> isinstance(iter('abc'), Iterator)
True

for 本质就是不停调用 next()，对于 Iterable 对象，先使用 iter() 将其变为 Iterator

---

• 上一篇：「Python 基础」初始 Python
• 下一篇：「Python 基础」函数与高阶函数

PS：感谢每一位志同道合者的阅读，欢迎关注、评论、赞！