python运算符与表达式

第二章：运算符，表达式与内置对象

常量与变量

• 在Python中不需要事先声明变量名以及数字类型，直接赋值即可

x = 5
# 得到该变量类型
class_type = type(x)
print(class_type)
# 判断该变量类型
print(type(x) == int)
# 用来测试内置函数是否为指定类型
flag = isinstance(x, int)
print(flag)

• Python采用基于值的内存管理模式，运行过程是首先把等号右侧的值计算出来，然后在内存中寻找一个合适的位置放进去，最后创建变量指向这个地址

• Python变量并不直接存储值，而是存储该值得内存引用，这是Python变量可变的原因

• 虽然不需要指定类型，但是Python是强类型编程语言，Python解释器会自动推断变量的类型

  数字

  复数，实数，整数。

  • Python支持任意大的数字，具体大小完全取决于内存能够支持的范围
  • 由于精度问题，对实数的计算可能会有误差
  • 应该避免使用相等符号来判断两个实数是否相等，而应该使用绝对值足够小来判断
  • Python支持使用下划线提高数字可阅读性，但是不能使用在收尾和连续使用

  import math
  # 实数相加
  print(0.3 + 0.2)
  # 相减结果稍微有偏差：0.30000000000000004
  print(0.4 - 0.1)
  # 应该避免直接使用等号判断相等:False
  print(0.4 - 0.1 == 0.3)
  # 使用abs函数判断相等:True
  print(abs(0.4 - 0.3 - 0.1) < pow(10, -6))
  # 使用i或者j表示复数虚部
  x = 3 + 3j
  print(x)
  # 输出complex
  print(type(x))
  

  分数

• Fraction对象支持分数运算

from fractions import Fraction
# 创建分数对象
x = Fraction(2, 5)
print(x)
# 查看分子
print(x.numerator)
# 查看分母
print(x.denominator)
# 把实数转化为分数
y = Fraction(3.5)
print(y)

高精度实数

• Decimal类实现了更高精度的运算

# 0.1111111111111111
print(1 / 9)
# 0.111111111111111104943205418749130330979824066162109375
print(Decimal(1 / 9))
# 转为两个整数，这两个整数的商又恰好等于该实数
print(Decimal("3.14").as_integer_ratio())

字符串

• 在Python中没有字符串常量和变量的概念，只有字符串类型的常量和变量，单个字符也是字符串
• 支持使用加号连接字符串

# str类型
print(type('hello world'))
# 加上b表示字节串:bytes
print(type(b'hello world'))
# 对中文进行编码
print('古力'.encode("UTF-8"))
x = '\xe5\x8f\xa4\xe5\x8a\x9b'

运算符和表达式

• 圆括号明确和改变表达式运算顺序的利器，应该合理利用
• 运算符除了可以应用在算术加法以外，还可以用于元组，列表，字符串的链接，但是不支持不同对象类型的链接

成员测试运算符in与同一性测试运算符is

• is用来测试两个对象是否是用一个，如果返回True这说明两者具有相同的内存地址

x = [2, 212, 3]
# True
print(2 in x)
# True
print('ab' in 'abc')

# True
print(3 is 3)
x = [1, 2]
y = [1, 2]
# Flase
print(x is y)

位运算符与集合运算符

• 位运算符只能用于整数
• 每左移一位相当于乘以2，右移一位相当于除以2

x = {1, 2, 3}
y = {3, 4, 5}

# &：交集
print(x & y)
# |：并集
print(x | y)
# ^：对称差集
print(x ^ y)
# -：差集
print(x - y)

• python不支持++运算符

类型转化与类型判断

• 内置函数bin(). oct(). hex()可以将整数转为二进制，八进制，十六进制形式
• ord()用来返回单个字符的Unicode码，chr()返回Unicode码对应的值
• list(). tuple(). dict(). set(). frozenset()可以将其他类型数据转为列表，元组，字典，可变集合，和不可变集合
• list. tuple. dict. set. frozenset都是python的内置类，之所以可以调用，是因为简洁的执行力这些类的构造函数，由于调用该函数会生成新的类型，所以被称之为工厂函数
• type() 和instance()在一定程度上会影响多态，所以应该谨慎使用

最值与求和

• max(), min(), sum()这三个函数用来计算包含列表，元组等包含有限个元素可迭代对象中所有元素最大值，最小值以及所有元素之和。

from random import randint
# 生产10个1-100的随机数列表
a = [randint(1, 100) for i in range(10)]
print(a)
print(max(a), min(a), sum(a))

• max()和min()还支持defualt参数和key参数，defualt参数用来指定可迭代对象为空时默认返回的的值，key用来指定比较大小的依据或者规则

# 取出长度最大的字符串
print(max(['xxx', 'x', 'xxxxxxx'], key=len))
# 为空时，默认返回None
print(max([], default=None))

# 产生30个子列表的列表，每个子列表包含5个结语1-50之间的随机数
list = [[randint(1, 50) for i in range(5)] for j in range(30)]
print(list)

# 返回元素之和最大的子列表
print(max(*list, key=sum))
# 与上面等价
print(max(list, key=sum))
# 返回第二个元素最大的子列表
print(max(list, key=lambda x: x[1]))
# 等比数列前n项的和
print(sum(pow(2, i) for i in range(200)))
# 和上面等价，但是运行速度快得多
print(int('1' * 200, 2))

排序与逆序

• sorted()对可迭代对象进行排序

import random

x = list(range(11))
print(x)
# 打乱顺序
random.shuffle(x)
print(x)
# 以默认规则排序
print(sorted(x))
# 转为字符串以后的长度降序排列
print(sorted(x, key=lambda item: len(str(item)), reverse=True))
# 转化为字符串以后的大小升序
print(sorted(x, key=str))

x = ['aaa', 'bc', 'ab', 'b', 'd', 'ba']
# 先按照长度排序，长度一样的正常排序,使用reverse进行翻转
print(sorted(x, key=lambda item: (len(item), item), reverse=True))

枚举与迭代

• enumerate()函数从来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值得元组
• iter()方法用来返回指定对象的迭代器,next()方法用来返回可迭代对象中的下一个元素，等价于zip等对象的__next__()方法

from queue import Queue

# 枚举字符串中的元素
x = list(enumerate('apple'))
# [(0, 'a'), (1, 'p'), (2, 'p'), (3, 'l'), (4, 'e')]
print(x)

# 枚举列表中的元素
x = list(enumerate(['python', 'beautiful']))
# [(0, 'python'), (1, 'beautiful')]
print(x)

# 枚举range对象中的元素:0 1    1 2    2 3    3 4    4 5    5 6    6 7    7 8    8 9
for index, value in enumerate(range(1, 10)):
    print(index, value, end='\t')

print()
x = [1, 2, 3]
y = iter(x)
print(next(y))
print(next(y))
print(next(y))

# 创建队列对象
q = Queue()
print(q)
for i in range(5):
    q.put(i)
# 放入结束标志
q.put('end')


def get():
    return q.get()


# 连续执行get函数，知道该函数返回end:0   1  2  3  4
for item in iter(get, 'end'):
    print(item, end='\t')

# map对象支持next()函数
print()
x = map(int, '12345')
print(next(x), next(x), next(x), next(x))
# __next__()方法的等价于next(x)
print(x.__next__())

x = enumerate({
    'a': '91',
    'b': '31',
    'c': '51'
}.items())
# enumerate对象支持该方法
print(next(x))

map(),reduce(),filter()

• 这几个是常用的函数，也是Python函数式编程的重要体现，Python3版本reduce()并非内置函数，而是放到了标准库functools中

from random import randint
# 把列表中的元素作为字符串
x = list(map(str, range(5)))
print(x)


def add5(v):
    return v + 5


# 将1-20之间可以被2整除的数加上5再变为列表
x = list(map(add5, range(1, 20, 2)))
print(x)


def add(m, n):
    return m + n


# 把双参数函数映射到一个序列的所有元素
x = list(map(add, range(1, 10), range(5, 15)))
print(x)

# 与上面等价
x = list(map(lambda m, n: m + n, range(1, 10), range(5, 15)))
print(x)


# 自定义函数
def myMap(lst, val):
    return map(lambda item: item + val, lst)


# 0-9的整数加上10，定义成列表
x = list(myMap(range(10), 10))
print(x)


# 自定义函数
def myNewMap(iterable, op, valeue):
    if op not in '+-*/':
        return 'Error operator'
    func = lambda i: eval(repr(i) + op + repr(valeue))
    return map(func, iterable)


x = list(myNewMap(range(5), '+', 10))
print(x)

x = list(myNewMap(range(5), '-', 15))
print(x)


# 重新练习一道
def myNewMap(iter, op, val):
    if op not in '+-*/':
        return 'Error operator'
    func = lambda i: eval(repr(i) + op + repr(val))
    return map(func, iter)


x = list(myNewMap(range(5), '+', 5))
print(x)


# 产生一个30位的随机数字
x = randint(1, 1e30)
print(x)
# 提取每个数字
y = list(map(int, str(x)))
print(y)

• reduce()函数可以将一个接受两个参数的函数以迭代累计方式从左至右依次作用到一个序列或迭代器对象的所有元素上，并且允许指定一个初始值

from functools import reduce
# 该库提供了大量的运算功能
import operator


def add(m, n):
    return m + n


# 相当于（（1+2）+ 3）....
x = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
print(x)

seq = list(range(1, 10))
y = reduce(add, seq)
print(y)
# 与上面等价
y = reduce(lambda m, n: m + n, range(1, 10))
print(y)

# 普通加法
y = operator.add(3, 5)
print(y)

# 使用reduce
y = reduce(operator.add, seq)
print(y)

# 指定初始值
y = reduce(operator.add, seq, 5)
print(y)

y = reduce(operator.mul, seq, 5)
print(y)

# 转成字符串再累加
y = reduce(operator.add, map(str, seq))
print(y)

# 使用join方法实现字符串累加
y = ''.join(map(str, seq))
print(y)

# 产生50个范围在1-10的随机数列表
lst = [randint(1, 10) for i in range(50)]
print(lst)


# 统计元素出现次数
def countNum(dic, k):
    if k in dic:
        dic[k] += 1
    else:
        dic[k] = 1
    return dic


y = reduce(countNum, lst, {})
print(y)

• 内置函数filter()将一个单参数函数作用到一个序列上，返回该序列中使得该函数返回值为True的那些元素组成的filter低下，如果指定函数为None，则返回序列中等价于True的元素

seq = ['foo', 'x41', '?!', '**']


# 判断是否是字母或者数字
def func(x):
    return x.isalnum()


y = list(filter(func, seq))
print(y)

# 使用列表推导式实现相同功能
y = [x for x in seq if x.isalnum()]
print(y)

# 使用lambda表达式实现相同功能.????????????????????????????????????
y = list(filter(lambda n: n.isalnum, seq))
print(y)

# 指定函数为None
y = list(filter(None, [1, 2, 0, 3, 4, 0, 0]))
print(y)