The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
学习于《Python编程：从入门到实践》
不可分割的原子类型，包括整数和浮点数
a = 1 #普通赋值
a += 1 #增量赋值
a = b =1 #多重赋值
(x,y) = (1,2) #多元赋值
复数：real + imag j，虚数部分必须用j或J结尾
a_complex = 1+2j
a_complex #（1+2j）
complex(1,2) #（1+2j）
a_complex.conjugate() #共轭复数 (1-2j)
常用方法
abs(-1) #绝对值 1
divmod(10,3) #除留余数 （3，1）
pow(2,3) #幂次运算 8
round(5.6) #四舍五入 6
int()
float()
bool()
由Unicode码位构成的不可变序列
str1 = 'apple' #单引号和双引号不区分
str2 = "apple"\ #换行需要 \，不收录行前的空格 'apple2'
"2"
str3 = ''' apple
apple'''#三引号任意换行，收录空格 'apple\n apple'
str()
转义字符：\n（换行符）、\t（Tab制表符）、\'（单引号）、\"（双引号）、 \\ （反斜线）
chr(65) #整数对应的Unicode字符 A
ord("A) #相反 65
常用方法
a = "1-2-3-4-5"
b = a.split('-') #分割 ['1', '2', '3', '4', '5']
'*'.join(b) #合并 '1*2*3*4*5'
a.strip('\n') #去除两端指定字符
a.rstrip() #去除右端空格
a.lstrip()
a.find('1') #第一次出现的位置 0 未找到返回-1
a.rfind('1') #最后一次出现的位置
a.count("1") #子串出现的次数
a.replace("1","2",1) #替换指定字符串，替换一次。 #'2-2-3-4-5'
str1 = '1234567'
a[0] #'1'
a[0:2] #'12'
a[::-1] #逆置 '7654321'
a[-1:-3:-1] #负数索引从-1开始 '76'，步长不同向则为空
列表由一系列特定顺序排列的元素组成。
a_list = [1,"2",(1,),{22},[1,2]]
list((1,2)) # 创建 [1,2]
a_list[0] # 1 切片操作，同字符串一致
a_list[:2] #[1,"2"]
a_list[::-1]
常用方法
a_list[0] = 2 #修改 [2,"2",(1,),{22},[1,2]]
a_list[:2] = 1,2 #修改
a_list.append(2222) #增加 [1, '2', (1,), {22}, [1, 2], 2222]
a_list.insert(1,333) #插入指定位置 [1, 333, '2', (1,), {22}, [1, 2], 2222]
a_list.pop(0) #弹出指定位置值 1
a_list.remove(2) #删除指定的值 ValueError
del a_list[0] #删除指定位置元素，自动补齐
a_list.count("2") #统计值个数
a_list.sort(reverse=True) #永久排序，元素为同一类型时可以，a_list改变
b_list = sorted(a_list) #临时排序，a_list不变
a_list.extend(b_list)#合并，等价于a +=b
a_list.reverse() #逆置
len(a_list) #返回长度
不可变的列表
t = (1,) #单元素逗号结尾
t = (1,2)
t[0] #取值 1
tuple([1,2]) #创建 (1,2)
a,b = (1,2) #解包 a=1,b=2
python中唯一的映射类型，有键值对构成，键可以被哈希，不能重复，不可变，包括：布尔型，整型，浮点型，元组等。
a = {} #空字典，而不是空列表
a_dict = {1:3,2:4}
dict([[1,2]]) #创建，参数必须是双值子序列
a_dict[1] #访问 3
a_dict[3] = 5 #添加
a_dict[1] = 9 #修改 {1:9,2:4，3：5}
del a_dict[1] #删除键值对
常用方法
a_dict.keys() #键列表 dict_keys([1, 2, 3])
a_dict.values() #值列表 dict_values([9, 4, 5])
a_dict.items() #返回键值对元组列表，dict_items([(1, 9), (2, 4), (3, 5)])
a_dict.update(b_dict) #合并 ，b合并到a上
a_dict.pop(1) #弹出指定键
a_dict.clear() #清空 {}
分为可变集合和不可变集合，不可变集合相当于字典中键的集合，元素唯一。
a_set = {1,2}
a_set = set((1,2,3,3)) #{1, 2, 3}
常用方法
a_set.add(4) #添加 {1, 2, 3, 4}
a_set.remove(4) #删除 {1, 2, 3}
a_set.update(b) #更新
子集/超集判定： <、<=、>、>=
a = {1,2,3,4}
b = {2,3,4,5}
a|b #并集 {1, 2, 3, 4, 5}
a&b #交集 {2, 3, 4}
a-b #差集 {1}
a^b #对称差集 {1, 5} = 并集-交集
可用于所有集合的方法
s.issubset(t) # 如果s是t的子集，返回True
s.issuperset(t) # 如果s是t的超集，返回True
s.union(t) # 返回一个新集合（s和t的并集）
s.intersection(t) # 返回一个新集合（s和t的交集）
s.difference(t) # 返回一个新集合（s - t）
s.symmetric_difference(t)# 返回一个新集合（s ^ t）
s.copy() # 返回一个新集合，它是s的浅复制
仅用于可变集合的方法
s.update(t) # 用t中的元素更新s
s.intersection_update(t) # s中现在是s和t的交集
s.difference_update(t) # s中现在是（s - t）
s.symmetric_difference_update(t)
# s中现在是s和t异或的结果
s.add(obj) # 在s中添加对象obj
s.remove(obj) # 从s中删除对象obj，如果不存在则引发KeyError异常
s.discard(obj) # 如果obj是s的元素，就从s中删除
s.pop() # 删除s中任意一个对象，并返回
s.clear() # 删除集合s中的所有元素
for循环
for i in range(5):
print(i,end=" ") #0 1 2 3 4
print(1 if 2<3 else 2)#三元操作符
while循环
i =0
while(i<5):
print(i,end=' ')
i+=1 #0 1 2 3 4
break:结束循环
continue：跳过当前循环
pass:占位，无实际意义
for i in range(10):
if( i==1):
continue
elif(i==2):
pass
elif(i==6):
break
print(i,end=" ") #0 2 3 4 5
input()获取输入，返回字符串
message = input("请输入内容空格相隔：")
请输入内容空格相隔：1 2 3 4
a,b,c,d = message.split(" ")
a # "1"
print()输出
%s 字符串
%d 十进制数
%x 十六进制数
%o 八进制数
%f 浮点类型数
%e 以科学计数法表示的浮点数
%g 十进制或科学计数法表示的浮点数
%% 文本值%本身
n = 42
f = 7.03
s = 'string cheese'
# 以默认宽度格式化
'%d %f %s' % (n, f, s) # '42 7.030000 string cheese'
# 最小域宽10个字符，右对齐，左侧不够空格填充
'%10d %10f %10s' % (n, f, s) # ' 42 7.030000 string cheese'
# 将上例 ⬅️对齐
'%-10d %-10f %-10s' % (n, f, s) # '42 7.030000 string cheese'
# 将上例 ➡️对齐，最大字符宽度为4
'%10.4d %10.4f %10.4s' % (n, f, s) # ' 0042 7.0300 stri'
# 去掉最小域宽为10的限制
'%.4d %.4f %.4s' % (n, f, s) # '0042 7.0300 stri'
# 将域宽、字符宽度等设定为参数
'%*.*d %*.*f %*.*s' % (10, 4, n, 10, 4, f, 10, 4, s)
# ' 0042 7.0300 stri'
'{} {} {}'.format(n, f, s) # '42 7.03 string cheese'
# 指定插入的顺序
'{2} {0} {1}'.format(f, s, n) # '42 7.03 string cheese'
# 参数为字典或命名变量，格式串中标识符可以引用这些名称
'{n} {f} {s}'.format(n=42, f=7.03, s='string cheese') # '42 7.03 string cheese'
d = dict(n=42, f=7.03, s='string cheese') # {'f': 7.03, 'n': 42, 's': 'string cheese'}
# {0} 代表整个字典，{1}代表字典后面的字符串'other'
'{0[n]} {0[f]} {0[s]} {1}'.format(d, 'other') # '42 7.03 string cheese other'
'{0:d} {1:f} {2:s}'.format(n, f, s) # '42 7.030000 string cheese'
'{n:d} {f:f} {s:s}'.format(n=42, f=7.03, s='string cheese') # '42 7.030000 string cheese'
定义：
def doing(*args,**kwargs):
return 0 #可省
doing()
参数的传递
参数类型
def print_more(arg1, arg2, *rest_args):
print(arg1，end=" ")
print(arg2, end=" ")
print(rest_args)
print_more(3, 2, 1) #3 2 (1,)
def print_kwargs(**kwargs):
print(kwargs)
print_kwargs(arg1=1, arg2=2, arg3='a')
lisr = {'qq':'112'}
print_kwargs(**lisr)
结果:
{'arg1': 1, 'arg2': 2, 'arg3': 'a'}
{'qq': '112'}
匿名函数
a = lambda x:x**2
a(3) #9
class用来实例化对象
class Person():
pass
p = Person()
方法类型
类方法和静态方法类本身和类的实例化对象都可以调用，实例方法只能实例化对象调用。
class A():
count = 0
def __init__(self):
A.count += 1
@classmethod
def kid(cls):
print('A has', cls.count, 'little objects')
@staticmethod
def static_method():
print('Static method called!')
魔术方法
class Word():
def __init__(self, text):
self.text = text
def __eq__(self, word2):
return self.text.lower() == word2.text.lower()
first = Word('ha')
second = Word('HA')
first == second #True
__lt__(self, other) self < other
__le__(self, other) self <= other
__eq__(self, other) self == other
__ne__(self, other) self != other
__gt__(self, other) self > other
__ge__(self, other) self >= other
__add__(self, other) 加法 +
__sub__(self, other) 减法 -
__mul__(self, other) 乘法 *
__floordiv__(self, other) 整数除法 //
__truediv__(self, other) 真除法 /
__mod__(self, other) 取模算法 %
__divmod___(self, other) 内置divmod()函数
__pow__(self, other) 指数运算 **
__lshift__(self, other) 左移 <<
__rshift__(self, other) 右移 >>
__and__(self, other) 按位与 &
__or__(self, other) 按位或 |
__xor__(self, other) 按位异或 ^
__str__(self) 等价于str(self)，定义如何打印对象信息，print()、str()以及字符串格式化相关方法都会用到__str__()。
__repr__(self) 等价于repr(self)，交互式解释器适用此方法输出变量。
__len__(self) 等价于len(self)。