重拾Python之旅

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
#!/usr/bin/env python
#coding:utf-8

# http://www.he11oworld.com/course/54

# linux上必须写 #!/usr/bin/env python 它能够引导程序找到python的解析器,也就是说,不管你这个文件保存在什么地方,这个程序都能执行,而不用制定Python的安装路径。
# 如果是Windows操作系统,则不必写。
# #coding:utf-8

# #单行注释
#
# '''
# 多行注释
# '''
#
# """
# 或多行注释
# """

# python3:

python支持&|^位运算

# bool运算符
and #&&
or #||
not #!

3//2 #1 直接去掉小数
3/2 #1.5 不管是否整除都输出小数
4/2 #1.0
2**8 #256
# python没有++和--

type(10**100)
#<type 'long'> py2
#<class 'int'> py3
#两个版本有区别,在Python 3中,不再有long类型对象了,都归类为int类型。

id(233)
# Help on built-in function id in module builtins:

# id(obj, /)
# Return the identity of an object.

# This is guaranteed to be unique among simultaneously existing objects.
# (CPython uses the object's memory address.)

# 除了使用%求余数,还有内建函数divmod()——返回的是商和余数。
divmod(5, 2) #表示5除以2,返回了商和余数
# (2, 1)
divmod(9, 2)
# (4, 1)
divmod(5.0, 2)
# (2.0, 1.0)
# Help on built-in function divmod in module builtins:

# divmod(x, y, /)
# Return the tuple (x//y, x%y). Invariant: div*y + mod == x.

# round
# adj. 圆形的; 弧形的; 丰满的,肥胖的; 整数的;
# adv. 到处; 在周围; 迂回地; 朝反方向;
# prep. 大约; 绕过,环绕; (表示位置) 在…四周; 附近;
round(1.22222,2) #四舍五入,但有时由于十进制转二进制的问题导致结果不准确
#1.22
round(2.235, 2)
# 2.23 #应该是:2.24
# Help on built-in function round in module builtins:

# round(...)
# round(number[, ndigits]) -> number

# Round a number to a given precision in decimal digits (default 0 digits).
# This returns an int when called with one argument, otherwise the
# same type as the number. ndigits may be negative.

math.pow(4, 2)
# 16
# math.pow(x,y)等价于x ** y
# Help on built-in function pow in module builtins:

# pow(x, y, z=None, /)
# Equivalent to x**y (with two arguments) or x**y % z (with three arguments)

# Some types, such as ints, are able to use a more efficient algorithm when
# invoked using the three argument form.

print("123\b123")#'\b'等于backspace键,会在光标处删去一个字符并前移
#12123
print("123\000123")
#123 123
# 转义字符描述
# \(在行尾时) 续行符
# \反斜杠符号
# \'单引号
# \"双引号
# \a响铃
# \b退格(Backspace)
# \e转义
# \000空
# \n换行
# \v纵向制表符
# \t横向制表符
# \r回车
# \f换页
# \oyy八进制数,yy代表的字符,例如:\o12代表换行
# \xyy十六进制数,yy代表的字符,例如:\x0a代表换行
# \other其它的字符以普通格式输出,如\q输出\q

# str类型切片[x:y:z] z步长,z不可为0,z不写默认为1
lang = "012345678"
# 从x开始以z为步长,满足在x与y直接且不等于y的位置的所有元素
lang[:1]
# '0'
# 若什么都没截取到,返回 ''
lang[:0]
# ''
lang[:9]
# '012345678'
# 若x或y的值为正数或零,则“边界指针”从字符串的左边数起,
# 若为负数,则先按绝对值从右边数起转换为对应的正数
lang = "012345678"
# 012345678 正数索引
# -9-8-7-6-5-4-3-2-1 负数索引
# 当x或者y不写时,看z,
# 若z为正,则x默认为0,y默认为总长度,
# 若z为负,则y默认为 -1 (不转换为正数),x默认为 总长度 - 1.
lang[-1:] # == lang[8:]
# '8'
lang[:-1] # == lang[:8]
# '01234567'
lang[1:7:2]
# '135'
lang[1:7:-2]
# ''
lang[7:1:-2]
# '753'
lang[:7:2] # == lang[0:7:2]
# '0246'
lang[:5:-2]
# '86'
lang[-1::-2] #== lang[8::-2]
# '86420'

ord('a')
# 97 #'a'的Unicode码(与ascii一致)
ord(' ')
# 32 #' '的Unicode码(与ascii一致)
# Help on built-in function ord in module builtins:

# ord(c, /)
# Return the Unicode code point for a one-character string.

chr(97)
# 'a'
# Help on built-in function chr in module builtins:

# chr(i, /)
# Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.

cmp()
# py3取消了 cmp() 内建函数,改用 > < ==比较字符串

# is == 的区别
# is比较的是id,比较判断的是对象间的唯一身份标识
# ==比较的是值value是否相等,取决于__eq__()

#关于 bool 类型
# python 没有 ! 运算符,改用 not 运算符,对 bool 类型取反
!True
# File "<stdin>", line 1
# !True
# ^
# SyntaxError: invalid syntax
not True
# False

# 在python中 None, False, 空字符串"", 0, 空列表[], 空字典{}, 空元组()都相当于False

# 格式化字符串 %
"I like %s" % "python"
# 'I like python'
"%s like %s" % ("imlk","python")
# 'imlk like python'
# 多个参数时使用 tuple (元组)
"%(name)s like %(what)s" % {'name':'imlk', 'what':'python'}
# 'imlk like python'
# "%(name)s like %(what)s" % {'name':'imlk', 'what':'python'}
# ^ ^
# 配合字典使用注意标注参数类型

# 格式化字符串 format
# 占位符
# {[序号或唯一标识符][若该占位符参数为列表,此处可索引列表中元素,如[1]]:[填充字符][对齐方式 <^>(<是字符默认,>是整数和浮点数默认)][宽度][.n若明确参数类型f,则表示小数点后精度n,若不明确,对于str,截取前n个字符,对于浮点型,用科学记数法表示并把e以前的数字个数限制为n个][参数类型,如f,d,b二进制,o八进制,x十六进制]}
"{} like {}" .format("imlk","python")
# 'imlk like python'
"{1} like {0}" .format("python","imlk")#指定序号
# 'imlk like python'
"{name}s like {what}" .format(name ='imlk', what='python')#这样写,函数内部得到的是一个字典{'name':'imlk', 'what':'python'}
# 'imlks like python'
'{0[0]} like {0[1]}'.format(l)
# 'imlk like python'
'{:20}'.format(111)
# ' 111'
'{:20}'.format(111.0)
# ' 111.0'
'{:20}'.format('111')
# '111 '
'{:20.2}'.format(111.0)
# ' 1.1e+02'
'{:20.3}'.format(111.1111)
# ' 1.11e+02'
'{:20.2f}'.format(111.1111)
# ' 111.11'
'{:20.4}'.format('111.1111')
# '111\. '

# Help on method_descriptor:

# format(...)
# S.format(*args, **kwargs) -> str

# Return a formatted version of S, using substitutions from args and kwargs.
# The substitutions are identified by braces ('{' and '}').

# 可变长度函数参数
# *args 表示任何多个无名参数,它是一个 tuple (元组)
# **kwargs 表示关键字参数,它是一个dict,字典中的 key 是传入参数的名称的 字符串 ,value 是传入参数等号后的值
# 同时使用*args和**kwargs时,必须*args参数列要在**kwargs前

# 可将元组作为参数列表传入
# 例如:
t = ("python","imlk")
"{1} like {0}" .format(*t) # *接元组表示把元组解开作为参数传入
# 'imlk like python'
# 同理可将字典作为参数列表传入
# 例如:
d = {'name':'imlk', 'what':'python'}
"{name} like {what}" .format(**d)# **接字典表示把字典解开作为参数传入
# 'imlk like python'

# 参考:
# https://www.cnblogs.com/fengmk2/archive/2008/04/21/1163766.html
# https://www.cnblogs.com/benric/p/4965224.html

# 去除字符串两端的空格,返回去除后的字符串,源串不变,同类有lstrip()左,rstrip()右
# str.strip()
# Help on method_descriptor:

# strip(...)
# S.strip([chars]) -> str

# Return a copy of the string S with leading and trailing
# whitespace removed.
# If chars is given and not None, remove characters in chars instead.

# [] list 列表
# 类型不限 元素类型可异 有序 元素可重复 内容可变(原地改变,id不变)(append,insert,pop,extend等) 不可做为dic的key
list = [1,'233','imlk',True]
bool(list) #判断是否空列表若列表为空则返回False
int(list) #不合法!!!!!

# 长度
len(list)

# +,连接两个序列
# *,重复列表中的所有元素
# in 判断是否在列表中

# 最大最小
max(list)
min(list)

# 列表比较
# 同 str 中一样 cmp()在py3已经废弃,改用 < == >
# 按元素序号从左到右依次比较,若遇到类型不符则报错
list1 = [1,2]
list2 = [1,1]
list1 < list2
# False
list2 = [1,'1']
list1 < list2
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# TypeError: unorderable types: int() < str()
list2 = [2,'1']
list1 < list2
# True

# 列表反转
list[::-1]
# 或
reversed(list)#返回一个迭代器

# list 中的每一个位置实际上维护的是对对象的引用
l
# ['imlk', 'python']
l.append(l)
l
# ['imlk', 'python', [...]]
l[2]
# ['imlk', 'python', [...]]
l[2]
# ['imlk', 'python', [...]]
l[2][2][2][2]
# ['imlk', 'python', [...]]
li = ['emmmm']
l.append(li)
l
# ['imlk', 'python', [...], ['emmmm']]
li.append('233')
l
# ['imlk', 'python', [...], ['emmmm', '233']]
l.extend(l) #将一共可迭代的对象的全体内容加到该列表中
l
# ['imlk', 'python', [...], ['emmmm', '233'], 'imlk', 'python', [...], ['emmmm', '233']]
# Help on method_descriptor:

# extend(...)
# L.extend(iterable) -> None -- extend list by appending elements from the iterable

l.count('imlk') #找出某个元素出现的次数
# 2

# attribute
# vt. 认为…是; 把…归于; 把…品质归于某人; 认为某事[物]属于某人[物];
# n. 属性; (人或物的) 特征; 价值; [语法学] 定语;
hasattr(lang, '__iter__')
# 判断某个类或者对象,模块(module)是否有某种属性,函数
# Help on built-in function hasattr in module builtins:

# hasattr(obj, name, /)
# Return whether the object has an attribute with the given name.

# This is done by calling getattr(obj, name) and catching AttributeError.

# 查看语言保留字
import keyword
keyword.kwlist

# whitespace
# 网络 空白符; 空白字符; 空格; 白空格; 白空间;
# separator
# n. 分离器,分离装置; 防胀器;
s = "I am, writing\npython\tbook on line" #这个字符串中有空格,逗号,换行\n,tab缩进\t 符号
print s #输出之后的样式
# I am, writing
# python book on line
s.split() #用split(),但是括号中不输入任何参数
# ['I', 'am,', 'writing', 'python', 'book', 'on', 'line']
# 如果split()不输入任何参数,显示就是见到任何空白符号,就用其分割了。

# Help on method_descriptor:

# split(...)
# S.split(sep=None, maxsplit=-1) -> list of strings

# Return a list of the words in S, using sep as the
# delimiter string. If maxsplit is given, at most maxsplit
# splits are done. If sep is not specified or is None, any
# whitespace string is a separator and empty strings are
# removed from the result.

# () tuple 元组
# 类型不限 元素类型可异 有序 长度不可变 元素可重复 速度快 相当于常量 可以作为dic的key 可用在字符串的格式化中
t = 1,"23",[123,"abc"],("python","learn") #元素多样性,近list
t
# (1, '23', [123, 'abc'], ('python', 'learn'))
# 元组中只有一个元素时,应该加上逗号,以免造成误解
t = (3)
type(t)
# <class 'int'>
t = (3,)
type(t)
# <class 'tuple'>

# {} dict 字典
# 键/值对 原地修改 key不可重复 内容可变 键key必须是不可改变的数据类型,值value可以是任意类型
d = {}
# 利用元组建构字典
name = (["first", "Google"], ["second", "Yahoo"])
website = dict(name)
website
# {'second': 'Yahoo', 'first': 'Google'}
# 增加键值对
d['name'] = 'imlk'
d
# {'name': 'imlk'}
# 删除键值对
del d['name']
# 清空dict
d.clear()
d
# {}
# 检查字典中是否含有某个key
'name' in d
# False
d['name'] = 'imlk'
# 通过key获取字典中的value
d['name']
'imlk'
# 或者
d.get('name') #若不存在则返回None
# Help on method_descriptor:

# get(...)
# D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.

# Help on method_descriptor:

# setdefault(...)
# D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D

# Python只存储基本类型的数据,比如int、str,对于不是基础类型的,比如刚才字典的值是列表,Python不会在被复制的那个对象中重新存储,而是用引用的方式,指向原来的值。
# 可变集合都是unhashable类型的。

# 数据类型的拷贝
l = ['imlk','python']
li = l.copy() #list,dict支持copy,tuple不支持
(1,).copy()
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# AttributeError: 'tuple' object has no attribute 'copy'

# 深拷贝
import copy
li = copy.deepcopy(l)

# set([]) 集合 元素必须是hashable的(不能含有list dict set等。。。) 元素类型可异 不可重复 无序,不可索引,内容可变(unhashable) 原地修改
# {} #代表空字典,要建立空集合,不得不使用set()。

# frozenset([]) 不可变集合 与 set([]) 区别是hashable,不可变

# 集合运算
a = set('python')
b = set('python3')
a
# {'y', 't', 'h', 'p', 'o', 'n'}
b
# {'y', 't', '3', 'h', 'p', 'o', 'n'}
# 集合相等
a == b
# False
# 子集
a < b
# True
# 超集
a > b
# False
# 并集
a | b
# {'y', 't', '3', 'h', 'p', 'o', 'n'}
# 交集
a & b
# {'y', 't', 'h', 'p', 'o', 'n'}
# A相对B的差(补)
a - b
# set()
b - a
# {'3'}

print()
# Help on built-in function print in module builtins:

# print(...)
# print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

# Prints the values to a stream, or to sys.stdout by default.
# Optional keyword arguments:
# file: a file-like object (stream); defaults to the current sys.stdout.
# sep: string inserted between values, default a space.
# end: string appended after the last value, default a newline.
# flush: whether to forcibly flush the stream.