PYTHON部分基础D2

小整数对象池

# 小整数的定义是[-5,257）这些整数对象是提前建立好的，不会被垃圾回收
# 所有位于这个范围内的整数使用的都是同一个对象。
>>> a = 256
>>> b =256
>>> id(a)
140712987886192
>>> id(b)
140712987886192
>>> id(a) == id(b)
True
>>> a = 257
>>> b = 257
>>> id(a)
2798009431536
>>> id(b)
2798009010064
>>> id(a) == id(b)
False

数学计算函数（需要导入math这个库）

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字x的平方根
acos(x)	返回x的反余弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回x的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)
sin(x)	返回的x弧度的正弦值。
tan(x)	返回x弧度的正切值。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度

常量	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e，e即自然常数（自然常数）。

布尔型

# 非0为True，0为False
>>> bool("False")
True
>>> bool("True")
True
>>> True
True
>>> False
False
>>> bool(1)
True
>>> bool(0)
False
>>> bool(1.0)
True
>>> bool(0.0)
False
>>> bool([])
False
>>> bool(())
False
>>> bool({})
False
>>> bool('')
False
>>> True > False
True
>>> True < False
False
>>> True >=False
True
>>> True -1
0
>>> True + 1
2
>>> True *3
3
>>> False -1
-1

空值：None

# None值不可以进行各种方法调用
>>> bool(None)
False
>>> type(None)

列表

# 是一个有序可重复的元素集合，可嵌套、迭代、修改、分片、追加、删除，成员判断。
# 创建列表
>>> lis = []        # 创建一个空列表
>>> lis = [1, 2, 3]
>>> lis = [1, 'a', [11,22], {'k1':'v1'}]
>>> lis = [1, 2, [3, 4, 5]]
# 修改元素
>>> lis[0]
'a'
>>> lis[0] = "d"
>>> lis[0]
'd'
# 删除元素
# del语句或者remove(),pop()方法删除指定的元素。
>>> lis = ["a", "b", "c"]
>>> del lis[0]
>>> lis
['b', 'c']
>>> lis.remove("b")
>>> lis
['c']
>>> lis.pop()  # 默认删除最后一个元素
'c'
>>> lis
[]
# 特殊操作
>>> [1,2,3] + [4,5,6]
[1, 2, 3, 4, 5, 6]
>>> ['Hi!'] * 4
['Hi!', 'Hi!', 'Hi!', 'Hi!']
>>> 3 in [1,2,3]
True
>>> for x in [1,2,3]:\
...     print(x);
...
1
2
3
# 列表的常用函数
>>> s = [1, 4, 9, 16, 25]
>>> len(s)
5
>>> max(s)
25
>>> min(s)
1
>>> s = list((1, "a", "b", 2))
>>> s
[1, 'a', 'b', 2]

列表切片

list[start:end]
# 省略start表示以0开始，省略end表示到列表的结尾。
# 注意，区间是左闭右开的，[1:4]只截取索引为1-3的3个元素。
>>> a = [1,2,3,4,5,6,7,8,9,10]
>>> a[3:6]
[4, 5, 6]
>>> a[:7]
[1, 2, 3, 4, 5, 6, 7]
>>> a[2:]
[3, 4, 5, 6, 7, 8, 9, 10]
>>> s = a[:]
>>> s
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> s.remove(4)
>>> s
[1, 2, 3, 5, 6, 7, 8, 9, 10]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a[-1]
10
>>> a[-3]
8
>>> a[-5:]
[6, 7, 8, 9, 10]
>>> a[::-1]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> a[1:8:2]
[2, 4, 6, 8]
>>> a[1:8:-2]
[]
>>> a[-8::-2]
[3, 1]
>>> a[-8::2]
[3, 5, 7, 9]

多维列表

>>> a = [[1,2,3],[4,5,6],[7,8,9]]
>>> a[0][1]
2
>>> a = [[1,2,3],[4,5,6],[7,8,9],{"k1":"v1"}]
>>> a[3]["k1"]
'v1'

列表的遍历

a = [1,2,3,4,5,6]
---------------------------
for i in a:             # 遍历每一个元素本身
    print(i)
------------------------------
for i in range(len(a)):     # 遍历列表的下标，通过下标取值
    print(i, a[i])
--------------------------------
x = 9
if x in a:      # 进行是否属于列表成员的判断。该运算速度非常快。
    print("True")
else:
    print("False")

列表内置方法

方法	作用
append(obj)	在列表末尾添加新的对象
count(obj)	统计某个元素在列表中出现的次数
extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
index(obj)	从列表中找出某个值第一个匹配项的索引位置
insert(index, obj)	将对象插入列表
pop(obj=list[-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
remove(obj)	移除列表中某个值的第一个匹配项
reverse()	反向列表中元素
sort([func])	对原列表进行排序
copy()	复制列表
clear()	清空列表，等于del lis[:]

>>> lis = ["a", "b", "c", "d"]
>>> lis.append("A")
>>> lis
['a', 'b', 'c', 'd', 'A']
>>> lis.count()
Traceback (most recent call last):
  File "", line 1, in 
    lis.count()
TypeError: count() takes exactly one argument (0 given)
>>> lis.count("a")
1
>>> lis.extend(["a","b"])
>>> lis
['a', 'b', 'c', 'd', 'A', 'a', 'b']
>>> lis.count("a")
2
>>> lis.index("a")
0
>>> lis.index("A")
4
>>> lis.insert(3, "E")
>>> lis
['a', 'b', 'c', 'E', 'd', 'A', 'a', 'b']
>>> s = lis.pop()
>>> s
'b'
>>> lis
['a', 'b', 'c', 'E', 'd', 'A', 'a']
>>> s = lis.pop(4)
>>> s
'd'
>>> lis
['a', 'b', 'c', 'E', 'A', 'a']
>>> lis.remove(3)
Traceback (most recent call last):
  File "", line 1, in 
    lis.remove(3)
ValueError: list.remove(x): x not in list
>>> lis.remove("E")
>>> lis
['a', 'b', 'c', 'A', 'a']
>>> lis.reverse()
>>> lis
['a', 'A', 'c', 'b', 'a']
>>> newlis = lis.copy()
>>> lis
['a', 'A', 'c', 'b', 'a']
>>> newlis
['a', 'A', 'c', 'b', 'a']
>>> newlis.clear()
>>> newlis
[]
>>> lis.sort()
>>> lis
['A', 'a', 'a', 'b', 'c']

列表当做堆栈

# 列表在内存内部是顺序存储结构的，所以在其尾部的添加和删除动作
# append和pop方法的效率非常高，具备随机存取速度，也就是O(1)的时间复杂度
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

列表当作队列
效率并不高，弹出第一个元素的速度却不快（因为所有其他的元素都得跟着一个一个地往左移动一位）。通常我们使用queue.Queue作为单向队列，使用collections.deque作为双向队列。

元组

# 方括号括是列表，圆括号括是元组（不可变序列，元组嵌套列表，列表可变）
# 不能修改，不能新增，不能删除
>>> tup = ('a', 'b', ['A', 'B'])
>>> tup[2][0] = 'X'
>>> tup[2][1] = 'Y'
>>> tup 
('a', 'b', ['X', 'Y'])

字符串

>>> a = "Hello"
>>> b = "Python"
>>> a + b   # 运算速度慢，慎用
'HelloPython'
>>> a * 2
'HelloHello'
>>> a[1]
'e'
>>> a[1:4]
'ell'
>>> "H" in a
True
>>> "M" not in a
True
>>> print(r'\n')
\n

转义字符	描述
(在行尾时)	续行符
\	反斜杠符号
'	单引号
"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，例如：\o12代表换行
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\033	颜色控制

字符串内置方法，前十个为常用

方法	描述
string.encode(encoding='UTF-8', errors='strict')	以 encoding 指定的编码格式编码
string.find(str, beg=0, end=len(string))	检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.split(str="", num=string.count(str))	以str为分隔符切片 string，如果 num有指定值，则仅分隔num个子字符串
string.join(seq)	以string作为分隔符，将seq中所有的元素(的字符串表示)合并为一个新的字符串
string.lower()	转换 string 中所有大写字符为小写.
string.endswith(obj, beg=0, end=len(string))	检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.startswith(obj, beg=0,end=len(string))	检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.strip([obj])	在 string 上执行 lstrip()和 rstrip()
string.upper()	转换 string 中的小写字母为大写
bytes.decode(encoding='UTF-8', errors='strict')	Python3 中没有 decode 方法，但我们可以使用 bytes
string.count(str, beg=0, end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数对象的 decode() 方法来解码给定的 bytes 对象string，编码的结果是一个bytes对象。如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
string.capitalize()	把字符串的第一个字符大写
string.center(width)	返回一个原字符串居中,并使用空格填充至长度width的新字符串
bytes.decode(encoding='UTF-8', errors='strict')	Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象string，编码的结果是一个bytes对象。如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
string.expandtabs(tabsize=8)	把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
string.format()	格式化字符串
string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回False
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回True,否则返回False
string.isdecimal()	如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit()	如果 string 只包含数字则返回 True 否则返回 False.字符都是小写，则返回True，否则返回False
string.isnumeric()	如果string中只包含数字字符，则返回True，否则返回False
string.isspace()	如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle()	如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.ljust(width)	返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lstrip()	截掉 string 左边的空格
string.maketrans(intab, outtab)	maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。
string.partition(str)	有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.replace(str1, str2, num=string.count(str1))	把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.rfind(str, beg=0,end=len(string))	类似于find()函数，不过是从右边开始查找.
string.rindex( str, beg=0,end=len(string))	类似于 index()，不过是从右边开始.
string.rjust(width)	返回一个原字符串右对齐,并使用空格填充至长度width的新字符串
string.rpartition(str)	类似于 partition()函数,不过是从右边开始查找.
string.rstrip()	删除 string 字符串末尾的空格.
string.splitlines([keepends])	按照行('\r','\r\n',\n')分隔，返回一个包含各行作为元素的列表，如果参数keepends为False，不包含换行符，如果为True，则保留换行符。
string.startswith(obj, beg=0,end=len(string))	检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.swapcase()	翻转 string 中的大小写
string.title()	返回"标题化"的string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.translate(str, del="")	根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
string.zfill(width)	返回长度为 width 的字符串，原字符串 string右对齐，前面填充0
string.islower()	如果string中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)

字符串颜色控制
格式：\033[显示方式;前景色;背景色m正文\033[0m

前景色	背景色	颜色
30	40	黑色
31	41	红色
32	42	绿色
33	43	黃色
34	44	蓝色
35	45	紫红色
36	46	青蓝色
37	47	白色

显示方式	意义
0	终端默认设置
1	高亮显示
4	使用下划线
5	闪烁
7	反白显示
8	不可见

import time

print('\033[1;31m')
print('登录信息'.center(46, "*"), "\033[0m")
print('\033[34m*HOST:\t', "192.168.1.10")
print('*PORT:\t', "80")
print('*User:\t', "jack")
print('*TIME:\t', time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
print('\033[1;31m*' * 50, '\033[0m')
print("\033[32m欢迎登录！\033[0m")

image.png

字典
从Python3.6开始，字典是有序的！它将保持元素插入时的先后顺序.
没有索引下标的概念，更没有切片的说法，一个key只能对应一个值

# 创建空字典
dic = {}    
dic = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}
# 增加和修改
>>> dic = {'Name': 'Jack','Age': 7, 'Class': 'First'}
>>> dic["address"] = "Shanghai"
>>> dic["address"] = "Beijing"
>>> dic["Age"] = 18
>>> dic
{'Name': 'Jack', 'Age': 18, 'Class': 'First', 'address': 'Beijing'}
# 删除字典元素、清空字典和删除字典
>>> dic
{'Name': 'Jack', 'Age': '20', 'Class': 'First', 'sex': 'male'}
>>> del dic['Name']     # 删除指定的键
>>> dic
{'Age': '20', 'Class': 'First', 'sex': 'male'}
>>> a = dic.pop('Class')        # 弹出并返回指定的键。必须提供参数！
>>> a
'First'
>>> dic
{'Name': 'Jack', 'Age': 7}
>>> dic.clear()         # 清空字典
>>> dic
{}
>>> del dic         # 删除字典本身
>>> dic
Traceback (most recent call last):
  File "", line 1, in 
    dic
NameError: name 'dic' is not defined

#  遍历字典
dic = {'Name': 'Jack', 'Age': 7, 'Class': 'First'}

# 1  直接遍历字典获取键，根据键取值
for key in dic:
    print(key, dic[key])

# 2  利用items方法获取键值，速度很慢，少用！
for key,value in dic.items():
    print(key,value)

#3  利用keys方法获取键
for key in dic.keys():
    print(key, dic[key])

#4  利用values方法获取值，但无法获取对应的键。
for value in dic.values():
    print(value)

# 综合展示
>>> for i in 'adilwste':\
... dic[i] = ord(i);
...
>>> dic
{'a': 97, 'd': 100, 'i': 105, 'l': 108, 'w': 119, 's': 115, 't': 116, 'e': 101}
>>> for i in dic:\
... print(i,dic[i]);
...
a 97
d 100
i 105
l 108
w 119
s 115
t 116
e 101
>>> dic.popitem()
('e', 101)
>>> dic
{'a': 97, 'd': 100, 'i': 105, 'l': 108, 'w': 119, 's': 115, 't': 116}
>>> a = dic.popitem()
>>> a
('t', 116)
>>> dic
{'a': 97, 'd': 100, 'i': 105, 'l': 108, 'w': 119, 's': 115}

方法	作用
clear()	删除字典内所有元素
copy()	返回一个字典的浅复制
fromkeys()	创建一个新字典，以序列seq中元素做字典的键
get(key)	返回指定键的值，如果键不在字典中，则返回default值
items()	以列表返回可遍历的(键, 值) 元组对
keys()	以列表返回字典所有的键
values()	以列表返回字典所有的值
pop(key)	删除并返回指定key的值
popitem()	删除并返回字典的最后一个键值对，不接受参数。
setdefault(key, default=None)	和get()类似,但如果键不存在于字典中，将会添加键并将值设为default
update(dict2)	把字典dict2的键/值对更新到dict里

bytes

# 字符串是以字符为单位进行处理的，bytes类型是以字节为单位处理的。
# bytes通常用于网络数据传输、二进制图片和文件的保存等等
>>> b = str.encode('编码类型')
>>> b
b'\xe7\xbc\x96\xe7\xa0\x81\xe7\xb1\xbb\xe5\x9e\x8b'
>>> string = b'\xe7\xbc\x96\xe7\xa0\x81\xe7\xb1\xbb\xe5\x9e\x8b'.decode()
>>> string
'编码类型'

集合set

无序不重复元素，自动去重，set最多接收一个参数
>>> s = set([1,1,2,3,3,4])
>>> s
{1, 2, 3, 4}        # 自动去重
>>> set("it is a nice day")     # 对于字符串，集合会把它一个一个拆开，然后去重
{'s', 'e', 'y', 't', 'c', 'n', ' ', 'd', 'i', 'a'}
# 集合支持操作
>>> dir(set)
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']

# add、clear、copy、pop、remove、update
>>> s = set([1,1,2,3,3,4])
>>> s
{1, 2, 3, 4}        # 自动去重
>>> set("it is a nice day")     # 对于字符串，集合会把它一个一个拆开，然后去重
{'s', 'e', 'y', 't', 'c', 'n', ' ', 'd', 'i', 'a'}
>>> s = {1, 2, 3, 4}
>>> s
{1, 2, 3, 4}
>>> s.add(5)
>>> s
{1, 2, 3, 4, 5}
>>> s.add(5)
>>> s
{1, 2, 3, 4, 5}
>>> s
{1, 2, 3, 4, 5}
>>> s.update("hello")
>>> s
{1, 2, 3, 4, 5, 'e', 'o', 'l', 'h'}
>>> s
{1, 2, 3, 4, 5, 'e', 'o', 'l', 'h'}
>>> s.remove("l")
>>> s
{1, 2, 3, 4, 5, 'e', 'o', 'h'}
>>> s.pop()
1
>>> s
{2, 3, 4, 5, 'e', 'o', 'h'}

# in 交并集
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 删除重复的
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 检测成员
True
>>> 'crabgrass' in basket
False
>>> # 以下演示了两个集合的交、并、差操作
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # a 中唯一的字母
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 在 a 中的字母，但不在 b 中
{'r', 'd', 'b'}
>>> a | b                              # 在 a 或 b 中的字母
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 在 a 和 b 中都有的字母
{'a', 'c'}
>>> a ^ b                              # 在 a 或 b 中的字母，但不同时在 a 和 b 中
{'r', 'd', 'b', 'm', 'z', 'l'}