python学习

输出函数

# 输出函数的逗号会转化为空格
print('The quick brown fox', 'jumps over', 'the lazy dog')

输入函数

# 输入函数是字符串，可以通过int函数转化为整型
birth = input('birth: ')
# 转化为整型，需要重新赋值
birth = int(birth)

常量

纯大写字母表示常量

数据类型

整型、浮点数、字符串、布尔值，空值

# \作为转义字符
print('I \'m ok')

# r表示不转义字符
print(r'\\\t\\')

# '''...'''表示多行代码
print('''line1
line2
line3''')
# 字符串的replace函数改变需要赋值给变量
a = 'abc'
a = a.replace('a', 'A')

None表示空值

变量

python是动态语言，变量类型随时可以变化。

编码

ASCII -> Unicode -> UTF-8
内存时编码为Unicode，保存时转化为UTF-8；服务器编码为Unicode，浏览器转化为UTF-8

# ord函数是字符转化为ASCII码
print(ord('A'))
# chr函数是ASCII码转化为字符
print(chr(66))
# b前缀表示二进制，字符串则是普通字符，即英文字母
x = b'ABC'
# encode是转化为指定编码
'ABC'.encode('ascii')
# decode是二进制解码为指定编码
print(b'ABC'.decode('ascii'))
# 忽略解码失败的字符
b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')

列表

等价于java的数组

classmates = ['Michael', 'Bob', 'Tracy']
# 列表的len函数计算列表长度
len(classmates)
# 列表的下标为负数是逆序
classmates[-1]
# 列表的下标越组会报错
classmates[-4]
# 列表的append函数为新增数据到列表尾
classmates.append('Adam')
# 列表的append函数为插入数据到指定下标
classmates.insert(1, 'Jack')
# 列表的pop函数为删除指定下标数据，无传入参数默认删除列表尾数据
classmates.pop(1)

元组

元组与列表区别是初始化后值不能改变

('Michael', 'Bob', 'Tracy')
# 元组的元素只有一个的时候，通过逗号去除歧义小括号的整型1
t = (1,)
# 改变只是引用，值没有变
t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
# 程序报错，因为值改变了
t[0] = 's'

字典

等价于java的map

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
# 字典的key重复插入会更新value值
d['Adam'] = 67
d['Adam'] = 90
# 字典获取不存在的key，会报错；用get方法替换
d['Thomas']
# 字典没有对应key，返回None
d.get('Thomas')
# 字典没有对应key，返回默认值-1
print(d.get('Thomas'), -1)
# 字典的pop函数是删除指定key-value
d.pop('Bob')
# 字典的pop函数删除不存在的key报错
d.pop('Bob1')
# 字典字符串、整型不可变，可以作为key；数组是可变，不能作为key
key = [1, 2, 3]
# 字典不能用可变的数组作为key，会报错
d[key] = 'a list'

集合

等价于java的hashset

s = {1, 2, 3}
# 集合可以重复添加，不会报错
s.add(4)
s.add(4)
# 集合不存在的key不可重复删除，会报错
s.remove(4)
s.remove(4)
# 集合的sort函数可以排序
a.sort()

分支语句

# if
if age >= 18:
    print("your age is", age)
    print("adult")
# if-else
if age >= 18:
    print("your age is", age)
    print("adult")
else:
    print("your age is", age)
    print("teenager")
# if-elif
if age >= 18:
    print("adult")
elif age >= 6:
    print("teenager")
# if-elif-else
if age >= 6:
    print('teenager')
elif age >= 18:
    print('adult')
else:
    print('kid')
# match
match score:
    case 'A':
        print('score is A.')
    case 'B':
        print('score is B.')
    case 'C':
        print('score is C.')
    case _:
        print('score is ???.')

循环语句

names = ['Michael', 'Bob', 'Tracy']
# for循环
for name in names:
    print(name)
# while循环
while n <= 100:
    print(n)
    n = n + 1

位置参数

位置参数是根据参数的顺序设置位置

# x和n都是位置参数
def power(x, n):
    result = 0
    while n > 0:
        n = n - 1
        result += x * x
    return result

默认参数

# n=2是将n的默认参数设置为2，n不是必传，不传的话值是等于2
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

可变参数

# 可变参数是将参数通过*转化成元组
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

关键词参数

# 关键词参数是额外传输一个字典，属性名为other
def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

命名关键字参数

# *代表可变参数，*后面的city和job代表必传参数，即命名关键词参数
def person(name, age, *, city, job):
    print(name, age, city, job)
# city设置默认值可以不必传
def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)

参数组合

由位置参数，默认参数，可变参数，关键词参数，命名关键词参数组合。
参数顺序：

1. 位置参数
2. 默认参数
3. 可变参数
4. 关键词参数
5. 命名关键词参数

切片

# 取前三个，返回列表
L[0:3]
L[:3]
# 取倒数第1个，返回对象
L[-1]
# 取倒数后2个，返回列表
L[-2:]
# 取倒数第1个，返回列表
L[-1:]
# 取前10个，间隔2个取数，返回列表
# 第一个冒号是取值范围，第二个冒号后面是间隔个数取值
L[:10:2]
L[::5]
# 复制列表
L[:]

迭代

# 字典遍历的是key
for key in d:
    print(key)
# 字符串也可以遍历
for ch in 'ABC':
    print(ch)
# 需要下标的遍历方法
for i, value in enumerate(['A', 'B', 'C']):
     print(i, value)
# 遍历多个变量
for x, y in [(1, 1), (2, 4), (3, 9)]:
     print(x, y)

列表生成式

# x的平方循环1-10生成列表
[x * x for x in range(1, 11)]
# x的平方循环1-10只取偶数生成列表
[x * x for x in range(1, 11) if x % 2 == 0]
# 笛卡尔积取m+n生成列表
[m + n for m in 'ABC' for n in 'XYZ']
# 同时迭代key和value
for k, v in d.items():
    print(k, v)
# 字典迭代key和value生成列表
[k + '=' + v for k, v in d.items()]
# 纯小写字母生成列表
[d.lower() for d in L]
# else是if不成立的时候走的逻辑
[x if x % 2 == 0 else -x for x in range(1, 11)]

生成器

# 生成器通过next函数访问下一个值
g = (x * x for x in range(10))
next(g)
next(g)

# a, b = b, a + b 等价于
# t = (b, a + b)
# a = t[0]
# b = t[1]

# 如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator函数
# 遇到yield就相当于调用next()返回当前循环的值
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

fib(6)
for n in fib(6):
    print(n)

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)
# 每次都是新建的
next(odd())
next(odd())
next(odd())
# 输出衔接上一个next函数的值
g = odd()
next(g)
next(g)
next(g)

迭代器

rom collections.abc import Iterable, Iterator

# 判断是否for循环
isinstance([], Iterable)
isinstance({}, Iterable)
isinstance('abc', Iterable)
isinstance((x for x in range(10)), Iterable)
isinstance(100, Iterable)

# 判断是否next
isinstance((x for x in range(10)), Iterator)
isinstance([], Iterator)
isinstance({}, Iterator)
isinstance('abc', Iterator)

# 判断是否转化迭代器
isinstance(iter([]), Iterator)
isinstance(iter('abc'), Iterator)