是计算一个数的商和余数的时候,发现基础的内建函数还没有掌握,今天空了来补一下。以下的列子均是在Python3里面支持的。
那就从第一个开始求余数和商开始吧。
divmod()
函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。abs
,比如求任意一个数的x进制,如果是复数就可以用上这个 abs,
对应的加上一个 signal -
。digits = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
if base > len(digits):
raise ValueError("Bases greater than 36 not handled in base_repr.")
elif base < 2:
raise ValueError("Bases less than 2 not handled in base_repr.")
num = abs(number)
res = []
while num:
num, r = divmod(num, base)
#res.append(digits[num % base])
#num //= base
res.append(digits[r])
if padding:
res.append('0' * padding)
if number < 0:
res.append('-')
return ''.join(reversed(res or '0'))
但是还可以用切片的方式来处理这个算法,
def numberToBase(n, b):
if n == 0:
return [0]
digits = []
while n:
digits.append(int(n % b))
n //= b
return digits[::-1]
**
的计算结果, 比如pow(2,2) = 2**2>>> round(2.456, 2)
2.26
>>> pow(3, 3)
27
>>> sum([0,1,2,3,4], 2) # 列表计算总和后再加 2
12
>>> s = [2,3,4,1]
>>> max(s)
4
>>> min(s)
1
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
下面就是每个0.5s间隔打一个点,就是类似loading.......
的动态效果
print("Loading",end = "")
for i in range(20):
print(".",end = '',flush = True)
time.sleep(0.5)
>>>issubclass(bool, int) # bool 是 int 子类
True
>>> int('0xa',16)
10
# 注意:这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错
>>> complex("1+2j")
(1 + 2j)
>>> bin(10)
'0b1010'
>>> oct(20)
'0o24'
>>> hex(12)
'0xc'
>>> tuple({1:2,3:4}) #针对字典 会返回字典的key组成的tuple
(1, 3)
>>> s.reverse()
>>> s
[1, 4, 3, 2]
>>>myslice = slice(5) # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice] # 截取 5 个元素
[0, 1, 2, 3, 4]
>>> s
[1, 4, 3, 2]
>>> s[::-1]
[2, 3, 4, 1] #可以有reverse的效果
>>> str(s)
'[1, 4, 3, 2]'
>>> bytes('xxd', 'utf-8')
b'xxd'
>>> bytes('叉叉敌', 'utf-8')
b'\xe5\x8f\x89\xe5\x8f\x89\xe6\x95\x8c'
>>> ord('a')
97
>>> ord('A')
65
>>> chr(97)
'a'
>>> repr(s)
'[1, 4, 3, 2]'
不能再添加或删除任何元素
。对象可以list, dict,tuple等>>> dict(a='a', b='b', t='t') # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> set(s)
{1, 2, 3, 4}
>>> ss = [2,3,4,5]
>>> set(ss)
{2, 3, 4, 5}
>>> set1 = set(ss)
>>> set2 = set(s)
>>> set1 |set2
{1, 2, 3, 4, 5}
>>> set1 - set2
{5}
>>> set2 - set1
{1}
>>> adict = {}
>>> fs = frozenset(s)
>>> adict[fs] = 123
>>> adict
{frozenset({1, 2, 3, 4}): 123}
# 获取对象属性后返回值可直接使用
>>> class A(object):
... def set(self, a, b):
... x = a
... a = b
... b = x
... print a, b
...
>>> a = A()
>>> c = getattr(a, 'set')
>>> c(a='1', b='2')
2 1
>>> for i,v in enumerate(s):
... print(i,v)
...
0 1
1 4
2 3
3 2
元素除了是 0、空、None、False 外都算 True。 any下同。
在 Python 3.x 中为了减少内存,zip() 返回的是一个对象。如需展示列表,需手动 list() 转换。
>>> zipped = list(zip(s,ss)) # 打包
>>> zipped
[(1, 2), (4, 3), (3, 4), (2, 5)]
>>> zip(*zipped)
<zip object at 0x105c89190>
>>> list(zip(*zipped)) # 与 zip 相反,*zipped 可理解为解压,返回二维矩阵式
[(1, 4, 3, 2), (2, 3, 4, 5)]
import math
def is_sqr(x):
return math.sqrt(x) % 1 == 0
newlist = filter(is_sqr, range(1, 101))
print(newlist)
:: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
不过map要多个迭代参数
>>>def square(x) : # 计算平方数
... return x ** 2
...
>>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
# 提供了两个列表,对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
全部局部变量
。>>> def testlocals(arg):
... x = 1
... print(locals())
...
>>> testlocals(4)
{'arg': 4, 'x': 1}
全部全局变量
。>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 's': [1, 4, 3, 2], 'slice': slice(None, 2, None), 'ss': [2, 3, 4, 5], 'set1': {2, 3, 4, 5}, 'set2': {1, 2, 3, 4}, 'i': 3, 'v': 2, 'list1': <zip object at 0x105cd8410>, 'zipped': [(1, 2), (4, 3), (3, 4), (2, 5)], 'testlocals': <function testlocals at 0x105c497a0>}
>>> while True:
... x = next(it, 's')
... print(x)
... if x == 's':
... break
...
1
2
3
4
5
s
>>>str = "for i in range(0,10): print(i)"
>>> c = compile(str,'','exec') # 编译为字节代码对象
>>> c
<code object <module> at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 * 4 + 5"
>>> a = compile(str,'','eval')
>>> eval(a)
17
with open('file') as f:
f.write('ccd\n')
>>> def add(a, b):
... return a + b
...
>>> callable(add) # 函数返回 True
True
不需要实例化
,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等。class A(object):
bar = 1
def func1(self):
print ('foo')
@classmethod
def func2(cls):
print ('func2')
print (cls.bar)
cls().func1() # 调用 foo 方法
A.func2() # 不需要实例化
还有一个比较常见的例子
#创建一个类
class Date(object):
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def print_date(self):
print(self.year, self.month, self.day)
#实例化类
data_object = Date('2018','10','31')
#执行输出函数
data_object.print_date()
2018 10 31
#在上面的例子中可以看到类的实例化需要传递‘年月日’三个参数。并且是要求分别传递。那么假设用户不按照要求填写,他填写的2018-10-31这样的一个参数呢?
#我们需要先对参数进行分割处理,然后再实例化类。例如下面的代码:
#分割函数
def from_string(date_as_string):
return map(int, date_as_string.split('-'))
#创建类
class Date(object):
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def print_date(self):
print(self.year, self.month, self.day)
#先执行分割函数对数据进行处理
year, month, day = from_string('2018-10-31')
#实例化类
data_object = Date(year, month, day)
#执行输出函数
data_object.print_date()
2018 10 31
#这样做视乎可以解决这个问题,但是from_string方法应该是属于类的一部分,现在需要写在外部,就导致了类功能外散,后期不便于管理,以后增加功能的时候会出现问题,所以我们就必须将from_string迁移到类里面去,并且还要在类的实例化之前调用它,我们都知道,一般情况下,如果想调用类中的方法,必须先实例化类,而我们现在的需求是要在实例化之前。这时就需要使用@classmethod咯。代码如下:
#创建一个类
class Date(object):
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def print_date(self):
print(self.year, self.month, self.day)
#声明类方法
@classmethod
def from_string(cls, date_as_string):
year, month, day = map(int, date_as_string.split('-'))
return cls(year, month, day) #实例化类并返回实例化对象
data_object = Date.from_string('2018-10-31')
#执行输出函数
data_object.print_date()
2018 10 31
#这是一个比较经典的案例,来自于stackoverflow。我暂时没有想到更好的,就先对原案例进行了一些修改并且加上了一些注释。
#使用@classmethod可以有效的防止类功能外散,可以将对属于当前类的功能集中起来,便于管理,并且对类的继承、重载、多态都是有一定的帮助,这个小例子只能算是一个用法说明,在实际的操作中会有更加复杂的用法,还需要以项目的实际业务逻辑来制定。
最大的差别就是,在这个方法里面不涉及其他类成员的功能函数方法。
因为这个方法声明后始终调用的是基类的方法。而classmethod始终是当前类的。 super()有一个非常好的优势,就是可以隐式的调用父类的当前类重载掉的方法。
https://www.zky.name/article/67.html
#声明A类
class A:
def __init__(self):
self.n = 2
def plus(self, m):
print('当前对象是 {} 来自 A类的plus方法'.format(self))
self.n += m
#声明B类,继承A类
class B(A):
def __init__(self):
self.n = 3
def plus(self, m):
print('当前对象是 {} 来自 B类的plus方法'.format(self))
#调用C类的plus方法
super().plus(m)
self.n += 3
#声明C类,继承A类。
class C(A):
def __init__(self):
self.n = 4
def plus(self, m):
print('当前对象是 {} 来自 C类的plus方法'.format(self))
#调用A类的plus方法
super().plus(m)
self.n += 4
#声明D类,继承B和C类,这样D类就有2个父类咯。B和C就成为了兄弟类。
#D类的MRO是[D,B,C,A,Object]
class D(B, C):
def __init__(self):
self.n = 5
def plus(self, m):
print('当前对象是 {} 来自 D类的plus方法'.format(self))
#调用B类的plus方法
#一定要记住一点,在这个例子里,所有类中的super()函数都没有指定参数,所以从D类一直super()到A类,所有的self都是D类的self。
super().plus(m)
self.n += 5
#实例化D类
d = D()
#调用D类的plus()方法
d.plus(2)
#输出D类的n属性
print(d.n)
out:
当前对象是 <__main__.D object at 0x000000000222DCF8> 来自 D类的plus方法
当前对象是 <__main__.D object at 0x000000000222DCF8> 来自 B类的plus方法
当前对象是 <__main__.D object at 0x000000000222DCF8> 来自 C类的plus方法
当前对象是 <__main__.D object at 0x000000000222DCF8> 来自 A类的plus方法
19
如果是多重继承,就需要 设置MRO并指定起始类
class D(B, C):
def __init__(self):
self.n = 5
def plus(self, m):
print('当前对象是 {} 来自 D类的plus方法'.format(self))
super(C,self).plus(m)
#super(C,D).plus(self,m) 和上一句效果相同。
self.n += 5
#实例化D类
d = D()
#调用D类的plus()方法
d.plus(2)
#输出D类的n属性
print(d.n)
输出结果:
当前对象是 <__main__.D object at 0x000000000280DCF8> 来自 D类的plus方法
当前对象是 <__main__.D object at 0x000000000280DCF8> 来自 A类的plus方法
12
>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'i', 'it', 'list1', 's', 'set1', 'set2', 'slice', 'ss', 'testlocals', 'time', 'v', 'x', 'zipped']
>>>
>>>help('sys') # 查看 sys 模块的帮助
……显示帮助信息……
int,float,bool,complex,str(字符串),list,dict(字典),set,tuple
参数必须支持缓冲协议,一般常用的就是
bytes以及bytearray
,由bytes和bytearray生成的元素都是单字节的,而由其他类型(例如array.array)生成的可能包含更大的元素
可以看到d和z都是一个地址
>>> z
b'a'
>>> memoryview(z)
<memory at 0x105ee4a10>
>>>
>>> d = z
>>> memoryview(z)
<memory at 0x105ee4d50>
>>> d
b'a'
>>> z
b'a'
>>> memoryview(d)
<memory at 0x105ee4d50>
>>> class User:
... def __init__(self):
... self._age = 0
... @property
... def age(self):
... '这是设置年龄的property属性'
... print('正在获取年龄属性')
... return self._age
... @age.setter
... def age(self, value):
... print('正在设置年龄属性')
... self._age = value
... @age.deleter
... def age(self):
... print('正在删除年龄属性')
... del self._age
...
>>> u = User()
>>> u.age = 18
正在设置年龄属性
>>> u.age
正在获取年龄属性
18
>>> del u.age
正在删除年龄属性