Python基础：语句与表达式

赋值语句

Python赋值语句跟js一样，比较多骚操作

基本赋值

x = 5
y = '6'

序列赋值

数值

(x, y) = (5, 10)
print(x, y)
x, y = 5, 10   # 省略括号 作用一样
print(x, y)
result = x + 20
print(result)   # 25
[x, y, z] = (10, 20, 30)  # 只要两边数量一样就行，会一一对应 对单个变量进行赋值
print(x, y, z)
x, y, z = z, y, x   # Python交换变量 非常方便
print(x, y, z)

字符串

a, b, c = 'jiu'      # 只要两边数量一样就行，会把字符串分割后 一一对应赋值给变量
print(a, b, c)
# a, b, c = 'jiuren'     # 两边数量不一致会报错

s = 'jiuren'
a, b, c = s[0], s[1], s[2:]  # 笨办法解决两边数量不一致
print(a, b, c)

扩展序列解包赋值：解决两边数量不一致

s = 'jiuren'
a, b, *c = s     # 一个表达式里只能一个星号
print(a, b, c)
a, *b, c = s
print(a, b, c)
print(type(b))   # 带*号的变量返回的是一个列表
b = ''.join(b)   # 把列表b用空字符连接成列表
print(b)

a, b, c, *d = 'jiu'
print(a, b, c, d)   # d由于字符串不够，所以d返回的是个空列表

# 如果两边刚好的话 返回一个列表，里面只有一个值

# 如果变量比字符串长度大2个以上，用这种方式也会报错
# 如：五个变量 字符串长度为3  a, b, c, d, e* = 'jiu'  会报错

多目标赋值

a = 'abc'
b = 'abc'
a == b  # True
a is b  # True

c = '我'
d = '我'
c == d   # True
c is d   # False   字符串缓存 跟int类型的那个256一样

a = b = c = 'jiuren'  # 多目标赋值，跟上面分开赋值结果一样
print(a, b, c)   # jiuren jiuren jiuren

Python学习之路-----小数字缓存、字符串缓存

可变类型(引用类型) 多目标赋值

a = b = []
a.append(3)
print(a, b)     # 引用类型改变后所有指向它的变量都会改变，输出：[3] [3]

a = []
b = []      # 或者 a, b = [], []
a.append(3)
print(a, b)     # [3] []

参数化赋值

a, b = 1, 2
a += b
a -= a
a *= b
a /= b

# 列表的参数化赋值 会把列表追加在一起
l = [1, 2]
l += [3, 4]
print(l)  # [1, 2, 3, 4]
# 效果跟.extend()的一样  .extend()是封装好的方法 效率更高
l.extend([8, 9, 10])   # 扩展列表(两个列表追加到一起)
print(l)
l.append(99)   # 追加一个值到列表
print(l)

表达式

len('abc')  # 函数的调用

l = [1, 2]
l.append(99)  # 方法的调用

print(l)  # 打印操作
a = '12345600'
b = '4579jjj'
print(a, b, sep="|")

print(a, end='|')
print(b, end='.....')

print(a, b, end='啦啦啦...\n', file=open('result.txt', 'w', encoding='utf-8'))
# 这样可以直接打印到一个自己新建的文件里

拓展：https://www.cnblogs.com/5bug/p/7612838.html

流程控制 => if语句

Python没有switch，if就足够了

if语句

score = 75

if score >= 90:
    print('优秀')
elif score >= 80:
    print('良好')
elif score >= 60:
    print('及格')
else:
    print('不及格')

用字典表模拟switch语句

def add(x):
    print(x + 10)


operation = {
    'aaa': add,                         # 参数可以传递一个函数
    'bbb': lambda x: print(x**2),       # 参数可以是一个lambda表达式(匿名函数)
    'add': '添加操作',
    'update': '更新操作',
    'delete': '删除操作'
}


def default_method(s):
    print(s)
    print('默认函数，什么都不做')


operation.get('update')
operation.get('bbb')(10)          # (10)是函数的参数
operation.get('ccccc', default_method)('get不到就执行这个函数：')

三元表达式(三元运算符)

score = 10
result = '及格' if score >= 60 else '不及格'
print(result)

流程控制 => 循环语句

Python只有while循环和for循环

while循环

x = '0000000.cn'
while x:  # 有值的字符串为True，序列里面有元素为True；int类型=0为False，None为False
    print(x,  end=' ')
    x = x[1:]  # 每打印一次字符串去掉一位

print('\n================================================================')

a, b = 0, 10
while a <= b:
    print(a, end=' ')
    a += 1

print('\n================================================================')

# continue
x = 10
while x:
    x -= 1
    if x % 2 != 0:      # 只打印偶数（余数为0）
        continue
    print(x, end=' ')

print('\n================================================================')

# break
while True:
    name = input('请输入姓名：')
    if name == 'stop':
        break
    age = input('请输入年龄：')
    print(f'您好：{name} 您的年龄是{age}')
else:           # Python的循环语句可以嵌套else
    print('循环结束...')
    # 上面的if条件不满足，没有跳出循环才会执行这里的打印，也就是说循环正常执行完毕就会执行else:
    # 但是实际上这是个死循环，无法正常执行完毕，所以这里加else其实是错误的，不会报错但无意义

for循环

range()
生成一个序列

for x in range(1, 101, 2):
    # range()返回的是可迭代对象，不是列表元祖什么的；第三个参数是补偿，为2
    print(x, end=' ')
    # 打印1-100，隔2个打印一下，得到的是偶数；但是这并不是求偶数的机制

found = False
for x in range(1, 2, 3, 5, 7):
    if x == 6:
        found = True
        print('已经找到了', x)
        break
if not found:   # 其他语言一般都用这种方式，而Python可以直接用else
    print('未找到...')

for x in range(1, 2, 3, 5, 7):
    if x == 6:
        print('已经找到了', x)
        break
else:           # Python的循环语句可以嵌套else
    print('未找到...')
    # 上面的if条件不满足，没有跳出循环才会执行这里的打印，也就是说循环正常执行完毕就会执行else:

所有可迭代对象/序列都可以进行遍历

遍历列表、元组、字符串

for x in [1, 2, 3, 'aaa']:
    print(x, end=' ')

for x in 'aaa11111':
    print(x, end=' ')

sum = 0
for x in (1, 2, 3, 4, 8, 50):
    sum += x  # 累加
print(sum)

遍历字典表

emp = {
    'name': 'JiuRen',
    'age': '23',
    'job': '捡破烂'
}

for key in emp:
    print('打印键和值 {} => {}'.format(key, emp.get(key, '没找到')))

for key in emp.keys():  # 跟直接遍历emp一样：直接遍历字典表遍历的是键
    print('只打印键', key)

for val in emp.values():  # 遍历值
    print('只打印值', val)

print(type(emp.values()))   # keys和values不是列表，是视图，属于可迭代对象

for循环进行交集

s1 = '0001010.cn'
s2 = '1101011.cn'
result = []
for x in s1:
    if x in s2:             # 用if in 判断x在s2里的话
        result.append(x)    # 追加给列表result
print(result)

# 用推导式直接一步到位
print([x for x in s1 if x in s2])

enumerate()：获取当前遍历的参数

s = 'jiuren'
for index, y in enumerate(s):
    print(index + 1, y)  # 1,j  2,i  3,u  ...

迭代

for循环就属于迭代，能用for循环的都是可跌带的对象(支持了迭代协议)

像文件这种带有自己的__next__()方法的实际上是在内部实现了某种机制，已经实现了next()，这种叫生成器或者迭代器对象，没有实现next()的可以用iter()来生成迭代器对象；使用for循环遍历的时候，实际上for循环已经在内部进行了iter()操作

for x in [1, 2, 3]:       # 列表
    print(x)

for x in (1, 2, 3):       # 元组
    print(x)

for k, v in {'a': 1, 'b': 1}:     # 字典表
#     print(k, v)  # Python2可以这样同时遍历字典表的键值 Python3不可以了(用其他方式)

# 文件支持next()，所以文件其实是个迭代器对象
with open('data.txt', encoding='utf-8') as f:
    print(f.read())       # 文件这些read相关的方法就是next()的效果
with open('data.txt', encoding='utf-8') as f:
    for line in f:     # for循环可直接遍历文件句柄，因为文件是可迭代的对象
        print(line)

# next()  __next__()
f = open('data.txt', encoding='utf-8')
print(f.__next__())
print(next(f))
# print(next(f))    # 一次迭代一个  直到最后没有可返回的值的时候抛出异常

# 只是for循环遍历看不出来有没有支持next()，可以用iter()这个函数来查看支不支持
print(iter(f) is f)   # 文件 返回True

l = [1, 2, 3, 4]
print(iter(l) is l)  # 列表返回False

ii = iter(l)       # 使用全局函数iter()，这样就支持next()了
print(ii.__next__())
print(ii.__next__())
print(next(ii))
print(next(ii))
# print(next(ii))     # 直到最后没有值了 抛出StopIteration

模拟for循实现过程

l = [1, 2, 3]
res = []
for x in l:
    print(res.append(x**2))

i = iter(l)     # 先把列表l(可迭代对象)转换成支持next()的 赋值给i
while True:
    try:
        x = res.append(next(i)**2)  # 这个时候就可以用next(i) 迭代i 每迭代一次**2
    except StopIteration:           # 直到最后没有可以迭代的了 出现这个异常的时候 跳出死循环
        break
print(res)  # 打印最后返回结果的列表

字典表 可迭代对象

emp = {'name': 'Tom', 'age': 20, 'job': 'dve'}
for k, v in emp.items():
    print('键:', k, '值:', v)     # 可以通过这种方式 打印键值

print(emp.items())
# .items()这个方法和keys()、values()一样
# 返回的不是列表 是一个个键值对应的一个元组：视图

for k in emp:
    print(k)   # 直接遍历字典表打印的只是键

emp.keys()    # emp.keys()获取到字典表的键  可以遍历它 通过get()它获取到对应的值
emp.values()  # emp.values()获取到字典表的值

# Python3的字典表改成可迭代对象了，在大集合的时候，可节省内存，
# 因为可以将其包装成迭代器，next()是使用一个提取一个，并不是事先存储在内存里的

keys = emp.keys()
print(iter(keys) is keys)   # 返回False 说明字典表是不支持next()的可迭代对象
lll = iter(keys)    # 调用这个方法就可以转换成带__next__()的可迭代对象了(迭代器)
# print(lll.__next__())
# print(next(lll))      # 依然跟上面一样可以调用全局的函数next()  或者 __next__()

推导的基本语法

所有的推导都可以用其他方式做到 但是推导简单方便

b = [1, 2, 3, 4]
tt = [x for x in b]
# 返回类型是由外侧的括号绝定的 如果外面用() 返回的结果就是带next()的可迭代对象
print(tt)

tt2 = [x+1 for x in b]
print(tt2)

urls = ['www.00000000.cn', 'www.baidu.com', 'www.555555.cn']
res3 = [url.upper() for url in urls]   # .upper() 是到大写
print(res3)
res4 = [url for url in urls if url.endswith('.cn')]   # .endswith() 过滤带.cn结尾的
print(res4)
# url是返回的结果 中间是遍历的过程 右边if是过滤的条件

内置可迭代对象

Python内置的一些可迭代函数

range()：可迭代对象

r = range(0, 11)
print(iter(r) is r)     # False   range()是可迭代对象 不是迭代器对象
r1 = iter(r)            # 将不是迭代器对象的可迭代对象r转换成迭代器对象 并赋值给r1
print(next(r1))
print(r1.__next__())   # 依然跟上面一样可以调用全局的函数next()或者迭代器对象自带的方法__next__()

一般像zip()、map()这些内置的迭代函数返回的都是迭代器，range()返回的是可迭代对象

zip()：带next()的可迭代对象(迭代器对象)

result = zip(['x', 'y', 'z'], [1, 2, 3])
print(result)         # zip() 函数可以将两个列表的值一一对应成元组
print(result.__next__())
print(result.__next__())
print(next(result))   # 不做任何操作即可调用全局的函数next()或者__next__()
# print(result.__next__())   # 报错

拓展：https://www.cnblogs.com/frydsh/archive/2012/07/10/2585370.html

map()：带next()的可迭代对象(迭代器对象)

def double(x):
    return x * 2


l = [1, 2, 3]

m = map(double, l)   # map()是把序列里的每个值放到一个函数里糟蹋一下，再返回糟蹋后的迭代器
print(m)
print(iter(m) is m)       # 返回True
print(m.__next__())       # 迭代器
print(next(m))

ll = list(map(double, l))    # map本身就是带next()的  放列表里等于遍历出来了
print(iter(ll) is ll)          # 返回False 因为ll是已经被转换成列表了的
print(ll)

关于迭代器、迭代对象，这都是以前的笔记，记得很乱

概念性的东西可以参考：https://blog.csdn.net/weixin_43040873/article/details/108686347