1. python基础
1.1 字符编码
- 1个字节能表示的最大的整数就是255（二进制11111111=十进制255）
- 2个字节可以表示的最大整数是65535
- 4个字节可以表示的最大整数是4294967295
| 编码类型 | 内容 | 问题 |
|---|---|---|
| ASCII | 目前为止共定义了128个字符，包括大小写字母、数字和一些符号，如A-65，z-122（图1） | 无法处理其他国家语言 |
| GB2312 | 中文编码 | 各国有各国标准，在多语言混合文本中，会有冲突，显示乱码 |
| Unicode | 将所有语言统一到一套编码，最常用的是用两个字节表示一个字符（如果要用到非常偏僻的字符，就需要4个字节） | 如果你写的文本基本上全部是英文的话，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上不划算 |
| 将Unicode编码转化为“可变长编码”的UTF-8编码 | UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节 | 这样一来，如果传输的文本包含大量英文字符，用UTF-8编码就能节省空间（图2） |
总结： 在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。
ord() 和 chr()
# ord()获取字符的整数表示，chr()把编码转换为对应字符
print(ord('A'))
print(ord('中'))
print(chr(66))
print(chr(25991))
>>> 65
>>> 20013
>>> B
>>> 文
encode() 和 decode()
Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。
# python中对 bytes 类型的数据，用带 b前缀的单引号/双引号表示
# 注意区分‘ABC’和 b'ABC'，前者为 str，虽然内容显示相同，但后者 bytes 的每个字符都只占用一个字节
# 1.以 Unicode 表示的 str 通过encode()方法可以编码为指定的 bytes
print('ABC'.encode('ascii'))
print('中文'.encode('utf-8'))
>>> b'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'
# 2.要把 bytes 变为 str ，就需要用 decode() 方法
print(b'ABC'.decode('ascii'))
print(b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8'))
print(b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')) # 忽略小部分无效字节
>>> ABC
>>> 中文
>>> 中
1.2 list 和 tuple
- list 列表是一种有序集合，可以随时添加和删除其中元素
- tuple 元组是一种有序列表，但是tuple一旦初始化就不能修改，安全性更高
# '可变的'tuple
t = ('a', 'b', ['A','B'])
t[2][0] = 'X'
t[2][1] = 'Y'
print(t)
>>> ('a', 'b', ['X', 'Y'])
1.3 dict 和 list
和list比较，dict有以下几个特点：
- 查找和插入的速度极快，不会随着key的增加而变慢
- 需要占用大量的内存，内存浪费多
list相反：
- 查找和插入的时间随着元素的增加而增加
- 占用空间小，浪费内存很少
注意： dict的key必须是不可变对象，这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法。
hash()
- 作用：将大的文件映射成一个小字符串，但hash算法不可逆，即不能通过hash值逆向推出key的值，因为可能存在不同key值对应相同的hash值
- 可哈希的数据类型：不可变的数据结构(字符串str、元组tuple、对象集objects)
- 不可哈希的数据类型：可变的数据结构 (字典dict，列表list，集合set)
2. 函数
2.1 自定义函数
返回多个值
多值返回时，返回值类型为tuple，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple 并按位置赋给对应的值。
2.2 函数参数
（1）位置参数
def power(x,n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
（2）默认参数
def power(x, n=2):
s = 1
while n > 0:
n = n-1
s = s * x
return s
注意：默认参数必须指向不变对象
def add_end(L=[]):
L.append('END')
return L
add_end()
add_end()
add_end()
>>> ['END', 'END', 'END']
解释： python函数在定义的时候，默认参数 L 的值就被计算出来了，为 [ ]。然后默认参数 L 也是一个变量，再调用该函数，默认参数的内容已经改变，不再是 [ ] 了。
修改： 用None这个不变对象实现
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
add_end()
（3）可变参数
允许你传入0或任意个参数，这些可变参数在函数调用时，会自动组装为一个tuple。
# 方法1 调用时，先组装出一个list 或 tuple
def calc(numbers):
sum = 0
for n in numbers:
sum = sum + n*n
return sum
calc([1,2,3])
# 方法2 简化调用，将函数参数改为可变参数
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum +n*n
return sum
calc(1,2,3)
# 如果已经有一个list 或 tuple，要调用一个可变参数怎么办
nums = [1,2,3]
calc(*nums)
（4）关键字参数
关键字参数允许传入0或者任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
person('Adam', 45, gender='M', job='Engineer')
>>> name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
extra = {'city': 'Beijing', 'job': 'Engineer'}
# **extra是把上述字典中的键值对用关键字参数传入到函数**kw参数，kw仅仅获得extra的一份拷贝，不会影响函数外的extra
person('Jack', 24, **extra)
>>> name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
（5）命名关键字参数
# 例如只接收city和job作为关键字参数
def person(name, age, *, city, job):
print(name, age, city, job)
总结
| 参数类似 | 功能/注意 |
|---|---|
| 位置参数 | 调用函数时，传入的值按照位置顺序依次赋给参数 |
| 默认参数 | 能简化函数调用难度，但要注意 一定要用不可变对象 |
| *args 可变参数 | 传入参数个数可变，args接收的是tuple。传入方法1：直接传入func(1, 2, 3)；传入方法2：先组装后传入func(*(1, 2, 3)) |
| **kw 关键字参数 | 传入参数含有的参数名可变，kw接收的是dict。传入方法1：直接传入func(a=1, b=2)；传入方法2：先组装后传入func(**{‘a’: 1, ‘b’: 2}) |
| 命名关键字参数 | 不要忘记写分隔符 * ，否则定义的是位置参数 |
2.3 递归函数
练习：汉诺塔递归
def move(n, a, b, c):
if n == 1:
print(a,"-->",c)
else:
move(n-1, a, c, b)
print(a,"-->",c)
move(n-1, b, a, c)
move(3, 'A', 'B', 'C')
>>>
A --> C
A --> B
C --> B
A --> C
B --> A
B --> C
A --> C
468
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
