Python复习笔记——基础知识

Python复习笔记—基础知识

Python变量

python允许多个变量指向同一个值

修改某个变量后该变量的内存地址变化

基于值的内存管理方式

• 为不同变量赋相同值，多个变量指向同一个值的内存空间
• Python启动时会对$[-5,256]$区间的整数进行缓存
• 同一个程序中，或者交互模式下同一句中同值的变量会共用同一个内存空间

赋值语句的执行过程

• 将等号后的表达式计算后，在内存空间中找到一个位置放置，然后创建变量指向该地址
• Python具有自动内存管理功能，会跟踪所有的值并自动删除不再使用或引用次数为0的值

Python定义变量名的规范

• 必须以字母、汉字或者下划线开头
• 不能含有空格及标点符号
• 不能使用关键字
• 大小写敏感
• 不能使用内置模块、类名或者函数名

运算符和表达式

加+

>>>[1,2,3]+[4,5,6] #连接两个列表
[1,2,3,4,5,6]
>>>(1,2,3)+(4,) #连接两个元组
(1,2,3,4)
>>> 'abcd'+'1234'
'abcd1234'
>>> 'A'+1 #不支持字符和数字相加
>>> True + 3 #Python内部将True作1处理
4
>>> False + 3 #Python内部将False作0处理
3

乘*

>>> 2.0 * 3                     #浮点数与整数相乘
6.0
>>> (3+4j) * 2                  #复数与整数相乘
(6+8j)
>>> (3+4j) * (3-4j)             #复数与复数相乘
(25+0j)
>>> "a" * 10                    #字符串重复
'aaaaaaaaaa'
>>> [1,2,3] * 3                 #列表重复
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> (1,2,3) * 3                 #元组重复
(1, 2, 3, 1, 2, 3, 1, 2, 3)

除/

"/"表示除法 "//"表示整除

>>> 3 / 5
0.6
>>> 3 / 5
0
>>> 3.0 / 5
0.6
>>> 3.0 // 5
0
>>> 13 // 10
1
>>> -13 // 10
-2

% 计算余数

由于浮点数的精度影响，计算结果可能略有误差

>>> 3.1 % 2
1.1
>>> 6 % 2.1
2.0999999999999996
>>> 6 % 2
0
>>> -17 % 4
3
>>> 17 % -4
-3
>>> 5.7 % 4.8
0.9000000000000004

关系运算符

可以连用

>>> 1 < 3 < 5                       #等价于1 < 3 and 3 < 5
True
>>> 'Hello' > 'world'               #比较字符串大小
False
>>> [1, 2, 3] < [1, 2, 4]           #比较列表大小
True
>>> 'Hello' > 3                     #字符串和数字不能比较
TypeError: unorderable types: str() > int()
>>> {1, 2, 3} < {1, 2, 3, 4}        #测试是否子集
True

运算符 in

可以测试一个对象是否为另一个对象的元素

>>> 3 in [1, 2, 3]       #测试3是否存在于列表[1, 2, 3]中
True
>>> 5 in range(1, 10, 1) #range()是用来生成指定范围数字的内置函数
True
>>> 'abc' in 'abcdefg'   #子字符串测试
True
>>> for i in (3, 5, 7):  #循环，成员遍历
    print(i, end='\t')   #注意，这里打两个回车才会执行

3	 5	7

运算符 is

用来测试两个对像是否是同一个。两个对象是同一个则两个对象具有相同的内存地址

>>> 3 is 3
True
>>> x = [300, 300, 300]
>>> x[0] is x[1]        #基于值的内存管理，同一个值在内存中只有一份
True
>>> x = [1, 2, 3]
>>> y = [1, 2, 3]
>>> x is y              #上面形式创建的x和y不是同一个列表对象
False

位运算符

只能用于整数

>>> 3 << 2    #把3左移2位
12
>>> 3 & 7     #位与运算
3
>>> 3 | 8     #位或运算
11
>>> 3 ^ 5     #位异或运算
6

集合

集合的交集、并集、对称差集等运算借助位运算符实现，差集使用减号实现

>>> {1, 2, 3} | {3, 4, 5}         #并集，自动去除重复元素
{1, 2, 3, 4, 5}
>>> {1, 2, 3} & {3, 4, 5}         #交集
{3}
>>> {1, 2, 3} ^ {3, 4, 5}         #对称差集
{1, 2, 4, 5}
>>> {1, 2, 3} - {3, 4, 5}         #差集
{1, 2}

and or

具有惰性求值特点

>>> 3>5 and a>3          #注意，此时并没有定义变量a
False
>>> 3>5 or a>3           #3>5的值为False，所以需要计算后面表达式
NameError: name 'a' is not defined
>>> 3<5 or a>3           #3<5的值为True，不需要计算后面表达式
True
>>> 3 and 5              #最后一个计算的表达式的值作为整个表达式的值
5
>>> 3 and 5>2
True
>>> 3 not in [1, 2, 3]   #逻辑非运算not
False
>>> 3 is not 5           #not的计算结果只能是True或False之一
True

Python不支持++ –

>>> i = 3
>>> ++i                       #正正得正
3
>>> +(+3)                     #与++i等价
3
>>> i++                       #Python不支持++运算符，语法错误
SyntaxError: invalid syntax
>>> --i                       #负负得正
3
>>> -(-i)                     #与--i等价
3

常用内置函数

• dir()函数可以查看指定模块中包含的所有成员或者指定对象类型所支持的操作。
• help()函数则返回指定模块或函数的说明文档。

bin()、oct()、hex()

• 内置函数bin()、oct()、hex()用来将整数转换为二进制、八进制和十六进制形式，这三个函数都要求参数必须为整数。

>>> bin(555)                      # 把数字转换为二进制串
'0b1000101011'
>>> oct(555)                      # 转换为八进制串
'0o1053'
>>> hex(555)                      # 转换为十六进制串
'0x22b'

int()

• 内置函数int()用来把实数转换为整数，或把数字字符串按指定进制转换为十进制数。

>>> int(3.5)
3
>>> int(-3.5)
-3
>>> int('101', 2)             # 二进制
5
>>> int('101', 16)            # 十六进制
257
>>> int('\t 8 \n')            # 自动忽略数字两侧的空白字符
8

ord() chr()

• ord()和chr()是一对功能相反的函数，ord()用来返回单个字符的序数或Unicode码，而chr()则用来返回某序数对应的字符，str()则直接将其任意类型参数转换为字符串。

>>> ord('a')                   >>> chr(65)
97                             'A'
>>> chr(ord('A')+1)            >>> str(1)
'B'                            '1'
>>> str(1234)                  >>> str([1,2,3])
'1234'                         '[1, 2, 3]'
>>> str((1,2,3))               >>> str({1,2,3})
'(1, 2, 3)'                    '{1, 2, 3}'

max() min() sum()

• max()、min()、sum()这三个内置函数分别用于计算列表、元组或其他可迭代对象中所有元素最大值、最小值以及所有元素之和，sum()要求元素支持加法运算，max()和min()则要求序列或可迭代对象中的元素之间可比较大小。

>>> import random
>>> a = [random.randint(1,100) for i in range(10)]   #列表推导式
>>> a
[72, 26, 80, 65, 34, 86, 19, 74, 52, 40]
>>> print(max(a), min(a), sum(a))
86 19 548
>>> sum(a)/len(a)
54.8

• 内置函数max()和min()的key参数可以用来指定比较规则。

>>> x = ['21', '1234', '9']
>>> max(x)
'9'
>>> max(x, key=len)
'1234'
>>> max(x, key=int)
'1234'

• 内置函数sum()的start参数可以用来指定求和的初值。

>>> sum([1,2,3,4])
10
>>> sum([1,2,3,4], 100)
110
>>> sum([[1], [2], [3], [4]], [])
[1, 2, 3, 4]

type() isinstance()

• 内置函数type()和isinstance()可以判断数据类型

>>> type([3])                             #查看[3]的类型
<class 'list'>
>>> type({3}) in (list, tuple, dict)      #判断{3}是否为list,tuple
                                          #或dict类型的实例
False
>>> isinstance(3, int)                    #判断3是否为int类型的实例
True
>>> isinstance(3j, (int, float, complex)) #判断3j是否为int,float
                                          #或complex类型
True

sorted()

• sorted()对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表

>>> x = ['aaaa', 'bc', 'd', 'b', 'ba']
>>> sorted(x, key=lambda item: (len(item), item))
                                #先按长度排序，长度一样的正常排序
['b', 'd', 'ba', 'bc', 'aaaa']
>>> import random
>>> data = random.choices(range(50), k=11)
>>> data
[21, 41, 49, 37, 30, 49, 8, 18, 33, 8, 0]
>>> sorted(data, reverse=True)
[49, 49, 41, 37, 33, 30, 21, 18, 8, 8, 0]
>>> sorted(data)[len(data)//2]  #奇数个数据的中位数
30

reversed()

• reversed()对可迭代对象（生成器对象和具有惰性求值特性的zip、map、filter、enumerate等类似对象除外）进行翻转（首尾交换）并返回可迭代的reversed对象。

>>> x = ['aaaa', 'bc', 'd', 'b', 'ba']
>>> reversed(x)                 #逆序，返回reversed对象
<list_reverseiterator object at 0x0000000002E6C3C8>
>>> list(reversed(x))           #reversed对象是可迭代的
['ba', 'b', 'd', 'bc', 'aaaa']

range()

• range()语法格式为range([start,] end [, step] )，返回具有惰性求值特点的range对象，其中包含左闭右开区间[start,end)内以step为步长的整数。参数start默认为0，step默认为1

>>> range(5)                  #start默认为0，step默认为1
range(0, 5)
>>> list(_)
[0, 1, 2, 3, 4]
>>> list(range(1, 10, 2))     #指定起始值和步长
[1, 3, 5, 7, 9]
>>> list(range(9, 0, -2))     #步长为负数时，start应比end大
[9, 7, 5, 3, 1]

enumerate()

• enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组

>>> list(enumerate('abcd'))                        #枚举字符串中的元素
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> list(enumerate(['Python', 'Great']))          #枚举列表中的元素
[(0, 'Python'), (1, 'Great')]
>>> list(enumerate({'a':97, 'b':98, 'c':99}.items())) #枚举字典中的元素
[(0, ('a', 97)), (1, ('b', 98)), (2, ('c', 99))]
>>> for index, value in enumerate(range(10, 15)):  #枚举range对象中的元素
    print((index, value), end=' ')

(0, 10) (1, 11) (2, 12) (3, 13) (4, 14) 

map()

• 内置函数map()把一个函数func依次映射到序列或迭代器对象的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理后的结果

>>> list(map(str, range(5)))  #把列表中元素转换为字符串
['0', '1', '2', '3', '4']
>>> def add5(v):              #单参数函数
    return v+5

>>> list(map(add5, range(10)))#把单参数函数映射到一个序列的所有元素
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> def add(x, y):            #可以接收2个参数的函数
    return x+y

>>> list(map(add, range(5), range(5,10)))
                              #把双参数函数映射到两个序列上
[5, 7, 9, 11, 13]
>>> import random
>>> x = random.randint(1, 1e30)     #生成指定范围内的随机整数
>>> x
839746558215897242220046223150
>>> list(map(int, str(x)))          #提取大整数每位上的数字
[8, 3, 9, 7, 4, 6, 5, 5, 8, 2, 1, 5, 8, 9, 7, 2, 4, 2, 2, 2, 0, 0, 4, 6, 2, 2, 3, 1, 5, 0]
>>> def check(s, lst):   #测试字符串是否包含列表中某个元素作为子串
    f = lambda item: item in s
    return any(map(f, lst))

>>> check('abcdefg', ['c', 'e'])
True
>>> check('abcdefg', ['i', 'h'])
False

filter()

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

>>> seq = ['foo', 'x41', '?!', '***']
>>> def func(x):
    return x.isalnum()                  #测试是否为字母或数字

>>> filter(func, seq)                   #返回filter对象
<filter object at 0x000000000305D898>
>>> list(filter(func, seq))             #把filter对象转换为列表
['foo', 'x41']
>>> list(filter(str.isalnum, seq))      #等价的用法
['foo', 'x41']
>>> data = list(range(20))
>>> data
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> filterObject = filter(lambda x:x%2==1, data)
                                 #过滤，只留下所有奇数
>>> filterObject
<filter object at 0x000001D602B85828>
>>> 3 in filterObject            #3以及3之前的元素都访问过了
True
>>> list(filterObject)           #现在所有元素都访问过了
[5, 7, 9, 11, 13, 15, 17, 19]
>>> list(filterObject)           #filterObject中不再包含任何元素
[]

zip()

• zip()函数用来把多个可迭代对象中的元素压缩在一起，返回一个可迭代的zip对象，其中每个元素都是包含原来的多个可迭代对象对应位置上元素的元组

>>> list(zip('abcd', [1, 2, 3]))             #压缩字符串和列表
[('a', 1), ('b', 2), ('c', 3)]
>>> list(zip('123', 'abc', ',.!'))           #压缩3个序列
[('1', 'a', ','), ('2', 'b', '.'), ('3', 'c', '!')]
>>> x = zip('abcd', '1234')
>>> list(x)
[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]

• map、filter、enumerate、zip等对象不仅具有惰性求值的特点，还有另外一个特点：访问过的元素不可再次访问

>>> x = map(str, range(10))
>>> list(x)
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
>>> list(x)
[]
>>> x = map(str, range(10))
>>> '2' in x
True
>>> '2' in x
False
>>> '8' in x
False

基本输入输出

input

• 在Python 3.x中，input()函数用来接收用户的键盘输入，不论用户输入数据时使用什么界定符，**input()**函数的返回结果都是字符串，需要将其转换为相应的类型再处理。

>>> x = input('Please input:')
Please input:3
>>> print(type(x))
<class 'str'>
>>> x = input('Please input:')
Please input:'1'
>>> print(type(x))
<class 'str'>
>>> x = input('Please input:')
Please input:[1,2,3]
>>> print(type(x))
<class 'str'>

print()

>>> print(3, 5, 7)
3 5 7
>>> print(3, 5, 7, sep=',')    #指定分隔符
3,5,7
>>> print(3, 5, 7, sep=':')
3:5:7
>>> for i in range(10,20):
    print(i, end=' ')          #不换行

10 11 12 13 14 15 16 17 18 19

Python代码规范

• 以#开始，表示本行#之后的内容为注释
• 包含在一对三引号’‘’…‘’'或"“”…“”"之间且不属于任何语句的内容将被解释器认为是注释