[abs, all, any, ascii, bin, bool, breakpoint, bytearray, bytes, callable, chr, classmethod, compile, complex, copyright,
credits, delattr, dict, dir, divmod, enumerate, eval, exec, exit, filter, float, format, frozenset, getattr, globals,
hasattr, hash, help, hex, id, input, int, isinstance, issubclass, iter, len, license, list, locals, map, max,
memoryview, min, next, object, oct, open, ord, pow, print, property, quit, range, repr, reversed, round, set,
setattr, slice, sorted, staticmethod, str, sum, super, tuple, type, vars, zip]
>>> abs(2.123) 如果大于0,返回自己
2.123
>>> abs(-2.123) 如果小于0,返回与自己的相反数
2.123
>>> abs(3+4j) 如果是复数,返回复数的模,定义复数的形式 a+bj. 他的模是开根号(a*a+b*b)
5.0
>>> all([-1,2,1])
True
>>> all([-1,2,0]) 0是假
False
>>> all([-1,2,False]) False也是假
False
判断假的有:0 False None,[],(),{}等等
注意:
>>> all([]) []是假为什么这里判断是真呢?
True
其实这里的all函数先去遍历可迭代对象.在判断对象里面的每一个元素是否为假.
如果没有元素可以迭代,那么返回真,看下面列子:
>>> all([[]]) 这里[[]]把空列表当成列表的元素传进去了,判断为假.返回假
False
看下面官方给出的解释:
def all ( iterable) :
for element in iterable:
if not element:
return False
return True
>>> any([])
False
官方的源码解释:
def any ( iterable) :
for element in iterable:
if element:
return True
return False
>>> ascii('z') 如果是ASCII值.返回本身且上 : '本身'
"'z'"
注意 返回的不是字符串z,而是'z' 长度是3
>>> len(ascii(1))
1
>>> len(ascii('z'))
3
>>> ascii('在') 非ASCII码,返回\x，\u或\U等字符来表示
"'\\u5728'"
注:判断一个值是否是ASCII值,程序如下:
>>> s=lambda x : ascii(x)==f"'{x}'" 还有一种写法:s=lambda x : ascii(x)==repr(x),还有一种更简单s=lambda x:x.isascii()
>>> s('a')
True
>>> s('在')
False
ASCII值如何解析成中文
>>> s=ascii('作者')
>>> s
"'\\u4f5c\\u8005'"
>>> s=s[1:-1]
>>> s
'\\u4f5c\\u8005'
>>> s.encode('utf-8').decode('unicode_escape')
'作者'
>>> bin(4) 参数是整形.直接返回二进制
'0b100'
>>> class test_bin():
def __init__(self,x):
self.x=x
def __index__(self): bin()直接调用该方法,必须实现
return self.x
>>> b=test_bin(3)
>>> bin(b) 参数是一个对象,调用对象的__index__函数
'0b11'
注:实际上实现__index__可以做一个比较6的特效
>>> ls=[1,2,3,4,5,6]
>>> b0=test_bin(3)
>>> b1=test_bin(5)
>>> ls[b0] 可以作为索引
4
>>> ls[b0:b1] 可以作为切片
[4, 5]
其实实现打印二进制的还有更灵活的方法:
>>> format(4,'#b') 利用format可以转为2,8,10,16进制,加#就是打印进制标识符.不加#则不加
'0b100'
>>> format(4,'b') 将十进制转为为二进制
'100'
>>> format(44,'#x') 十进制->十六进制
'0x2c'
>>> format(44,'#o') 十进制->八进制
'0o54'
>>> format(0x22,'#d') 十六进制->十进制
'34'
还有一种更是6的一批的方法.叫F-string,只从Python3.6之后正式加入标准库内,所以你可以大胆的使用,官方许可!
大写的F和小写的f是一样.不区分大小写
>>> f'{4:#b}' 和上面的使用方法一样.在这里就不多说了
'0b100'
>>> F'{4:b}' 一样和上面
'100'
下面是f-string的另一种用法,实际上他是format的简写
>>> name='你好'
>>> f'{name}世界'
'你好世界'
>>> '{t}世界'.format(t=name)
'你好世界'
>>> f'{2*32}' 实际上我们可以看得出.{}你们是一个可执行体
'64'
>>> f'{(lambda x : x+1)(2)}' 虽然f-string可以执行lambda表达式.但是不推荐这种做法.减少了可读性
'3'
>>> bool() 这个没有好说的.如果没有值.则默认是None.返回假
False
注:0, 0.0, 0j, Decimal(0), Fraction(0, 1) None and False '', (), [], {}, set(), range(0) 都是假
bool()输入的是一个对象的时候,无论对象是否实现,怎么实现.返回值都是真
>>> class A:
pass
>>> bool(A) 传的对象对象
True
>>> bool(A()) 传的对象类
True
第一种:三个参数都不填写,则返回空字节数组
>>> bytearray()
bytearray(b'')
>>> len(bytearray())
0
第二种:如果source参数填写的是字符串.那么encoding必须填写.
>>> bytearray(source='作者',encoding='utf-8')
bytearray(b'\xe4\xbd\x9c\xe8\x80\x85')
>>> bytearray(source='作者',encoding='GBK')
bytearray(b'\xd7\xf7\xd5\xdf')
第三种:如果source参数填写的是整数
第三种的第一种写法:
>>> bytearray(source=10) source必须是大于0的.意思是生成整数所指定长度的空字节数组
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
第三种的第二种写法:
>>> bytearray([1,2,3,4]) 当source参数是一个可迭代对象，那么这个迭代对象的元素都必须符合0 <= x < 256
bytearray(b'\x01\x02\x03\x04')
第四种:如果source参数是object.那么要实现buffer接口,使用只读方式将字节读取到字节数组后返回
>>> s='作者'.encode('utf-8')
>>> type(s)
<class 'bytes'>
bytes类型实现了buffer接口
>>> bytearray(source=s)
bytearray(b'\xe4\xbd\x9c\xe8\x80\x85')
注:bytearray()返回的对象是可修改的,下面将bytes返回来的是不可以修改的
>>> b=bytearray(10)
>>> b[1]
0
>>> b[1]=1 可修改
>>> b[1]
1
注: bytes和str类型的区别
bytes是byte的序列，而str是unicode的序列。
str 使用encode方法转化为 bytes
bytes通过decode转化为str
bytes和bytearray的区别
bytearray是可变的。bytes是不可变的.
第一种情况:对象能否使用()括号的方法调用
>>> callable(bool)
True
>>> callable(1)
False
第二种情况: 自定义的类,类对象一定可以被调用
>>> class test_callable():
pass
>>> callable(test_callable) 类对象
True
>>> callable(test_callable()) 类实例是否能被调用,取决于是否实现了__call__函数
False
第三种情况:类实例调用.实现__call__函数
>>> class test_callable:
def __call__(self): 实现了__call__函数
pass
>>> callable(test_callable())
True
注:实际上callable()无论传什么进去.他都相当于在执行一次实例:t=test_callable() --> t()
记住Python一切皆是对象
>>> t=test_callable()
>>> t() 正确.没有报错误
>>> test_callable()() 正确,没有报错误
>>> chr(1)
'\x01'
>>> chr(97)
'a'
>>> chr(1114111)
'\U0010ffff'
>>> chr(1114112) 如果超出1114111之后报ValueError
Traceback (most recent call last):
File "<pyshell#242>", line 1, in <module>
chr(1114112)
ValueError: chr() arg not in range(0x110000)
>>> class test_classmethod:
test=1
@classmethod
def method(cls):
return cls.test
>>> test_classmethod.method() 不要以为这个和Java的静态方法一致
1
1. source -- 字符串或者AST对象。。
2. filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
3. mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
4. flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
5. flags和dont_inherit是用来控制编译源码时的标志
第一种:编译为字节对象 返回值为None
>>> s='[print(x) for x in range(5)]'
>>> c=compile(s,'','exec') 编译为字节对象
>>> exec(c)
0
1
2
3
4
第二种:
>>> s='3+5'
>>> c=compile(s,'','exec')
>>> print(exec(c)) 返回None
None
>>> c=compile(s,'','eval') 提供返回值
>>> eval(c)
8
>>> complex() 不写参数默认是0
0j
>>> complex(1,2)
(1+2j)
>>> complex(1)
(1+0j)
>>> complex('1+2j') 注意:1+2j之间不能有空格
(1+2j)
>>> complex('1 + 2j') 1+2j之间有空格.报ValueError错误
Traceback (most recent call last):
File "<pyshell#4>", line 1, in <module>
complex('1 + 2j')
ValueError: complex() arg is a malformed string
关于两个复数的四则运算
>>> a=complex(1+2j)
>>> b=complex(2+3j)
>>> a-b
(-1-1j)
>>> a+b
(3+5j)
>>> a*b
(-4+7j)
>>> a/b
(0.6153846153846154+0.07692307692307691j)
复数的3个内置方法
>>> a.imag 虚根
2.0
>>> a.real 实根
1.0
>>> a.conjugate() 共轭复数
(1-2j)
>>> class A:
s=1
>>> a=A()
>>> a.s 能正常调用
1
>>> delattr(A,'s') 删除类对象中的s属性
>>> a.s 在调用s属性报错AttributeError
Traceback (most recent call last):
File "<pyshell#12>", line 1, in <module>
a.s
AttributeError: 'A' object has no attribute 's'
注:他的效果和del一样的
>>> del A.s
delattr函数删除的是类对象里面的属性.而并不是实例化对象里面的属性.所以就算在实例化其他对象.该对象里面仍然没有删除后的属性
实际上实例化对象是;类对象的复制品,因为是直接删除了类对象,所以就算在实例化其他,依然没有.
第一种生成字典的方式:
>>> dict(name='tyoui',age=25)
{'name': 'tyoui', 'age': 25}
第二种生成字典的方式:
>>> d={'name': 'tyoui', 'age': 25}
>>> d
{'name': 'tyoui', 'age': 25}
得到字典的值
>>> d['name']
'tyoui'
>>> d.get('name')
'tyoui'
可以设置get()的参数.如果没有找到值,则返回第二个参数自己定义的值
>>> d.get('name1','没有找到值')
'没有找到值'
可以抛出一个值,不建议在循环抛出
>>> d.pop('age') 实际上pop方法我们会写两个参数.如果存在键,抛出成功后会返回值.没有键或者没有成功,则抛出异常
25
>>> d.pop('age1','没有找到该键')第二个参数和get方法一样
'没有找到该键'
>>> d
{'name': 'tyoui'}
获取键值对列表
>>> d.items()
dict_items([('name', 'tyoui')])
获取键列表
>>> d.keys()
dict_keys(['name'])
获取值列表
>>> d.values()
dict_values(['tyoui'])
创建新字典,序列seq中元素做字典的键，value为字典所有键,fromkeys(seq,[value])
>>> d.fromkeys(['a','b','c']) 只是创建一个新的字典.并没有改变以前的值
{'a': None, 'b': None, 'c': None} 实际上他没有增加以前的键值,只是单纯的用seq作为键
>>> d
{'name': 'tyoui'}
>>> d.fromkeys(['a','b','c'],10)
{'a': 10, 'b': 10, 'c': 10}
清除字典
>>> d
{'name': 'tyoui'}
>>> d.clear() 清除
>>> d
{}
修改值
>>> s
{'a': None, 'b': None, 'c': None}
>>> s['a']=1
>>> s
{'a': 1, 'b': None, 'c': None}
将一个字典的键值对加入到另一个字典上
>>> d= {'name':'jtyoui'}
>>> s
{'a': 1, 'b': None, 'c': None}
>>> s.update(d)
>>> s
{'a': 1, 'b': None, 'c': None, 'name': 'jtyoui'}
随机的抛出一对键值对
>>> s.popitem()
('name', 'jtyoui')
>>> s
{'a': 1, 'b': None, 'c': None}
该setdefault方法有点类似get方法,不过这个方法如果有键.则返回值.没有键则增加键并且设置默认值
>>> d
{'name': 'jtyoui'}
>>> d.setdefault('age') 实际上第二个参数就是设置的值.如果没有默认是None
>>> d
{'name': 'jtyoui', 'age': None}
如果增加成功.则返回添加成功的值
>>> d
{'name': 'jtyoui'}
>>> d.setdefault('age',21) 返回21
21
>>> d
{'name': 'jtyoui', 'age': 21}
如果判断字典是否包含某个键
>>> d
{'name': 'jtyoui', 'age': 21}
>>> d.__contains__('age') 在Python2.x类似于has_key()方法
True
关于字典的复制问题,内置的是浅复制,这个重点说一下
浅复制实际上是复制了第一层的引用.并非全部拷贝
>>> q={'name':'jtyoui','age':[1,2,3]}
>>> q
{'name': 'jtyoui', 'age': [1, 2, 3]}
>>> s=q.copy()
>>> s
{'name': 'jtyoui', 'age': [1, 2, 3]}
开始增加属性
>>> s['sex']='boy' 实际上在第一层增加.并不会影响另一个字典
>>> s
{'name': 'jtyoui', 'age': [1, 2, 3], 'sex': 'boy'}
>>> q 还是原来的值
{'name': 'jtyoui', 'age': [1, 2, 3]}
修改两个字典引用了同一个列表
>>> s['age'].append(4) 在列表中增加值
>>> s
{'name': 'jtyoui', 'age': [1, 2, 3, 4], 'sex': 'boy'}
>>> q 居然他也发生变化了
{'name': 'jtyoui', 'age': [1, 2, 3, 4]}
注:关于深拷贝,需要导入copy模块.使用deepcopy方法
>>> import copy
>>> t=copy.deepcopy(q) 现在这两个字典,没有一点关系了,是实实在在的拷贝.不会影响到另一个
>>> t
{'name': 'jtyoui', 'age': [1, 2, 3, 4]}
下面举两个例子:
将两个列表合并成字典
>>> ls1=['a','b']
>>> ls2=[1,2]
>>> dict(zip(ls1,ls2))
{'a': 1, 'b': 2}
将嵌套列表中的可迭代对象转为字典
>>> ls=[('a',1),('c',2)]
>>> dict(ls)
{'a': 1, 'c': 2}
>>> dir() 当前范围内的属性
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
>>> dir([]) 列表里面的属性
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__',
'__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__',
'__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__',
'__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse',
'sort']
自定义一个类
>>> class test_dir:
s=1
def test(self):
pass
>>> dir(test_dir)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
'__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'__weakref__', 's', 'test'] -->'s', 'test'属性
自定义类中包括__dir__属性
>>> class test_dir:
s=1
def test(self):
pass
def __dir__(self):
return ['自定义属性']
>>> dir(test_dir()) 这里要传的是一个对象
['自定义属性']
>>> divmod(3,4)
(0, 3)
>>> divmod(-5,-6)
(0, -5)
>>> divmod(43.33,5.3)
(8.0, 0.9299999999999997)
>>> divmod(1+2j,3+4j) 不支持复数形式
Traceback (most recent call last):
File "<pyshell#28>", line 1, in <module>
divmod(1+2j,3+4j)
TypeError: can't take floor or mod of complex number.
注:实际上如果要计算复数形式;可以这样做,关于复数更多的知识请看 内置函数13 complex 和cmath模块
>>> (1+2j)/(2+1j)
(0.8+0.6j)
>>> ls=map(lambda x :chr(x),range(65,70)) 映射ASCII值
>>> list(enumerate(ls)) 遍历创建索引,默认是下标0开始
[(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'), (4, 'E')]
>>> list(enumerate(ls,start=65))下标为65开始
[(65, 'A'), (66, 'B'), (67, 'C'), (68, 'D'), (69, 'E')]
实现上用处最多的地方还是下面这种
>>> seq=['a','b','c']
>>> for i,v in enumerate(seq):
print(i,v)
0 a
1 b
2 c
关于Python非常彪悍的生成器,会有一大篇文章来讲述 yield
def enumerate ( sequence, start= 0 ) :
n = start
for elem in sequence:
yield n, elem
n += 1
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
>>> eval('3+4')
7
>>> eval('abs(-123)')
123
>>> a=1
>>> eval('a+2') 实际上他把a当成变量
3
我们来试一下什么是变量作用域
>>> x,y=1,2
>>> eval('x+y')
3
>>> def test_eval():
x,y=3,3 局部变量
n1=eval('x+y') 局部变量
n2=eval('x+y',locals()) 局部变量
n3=eval('x+y',globals()) 全局变量
print(n1,n2,n3)
>>> test_eval()
6 6 3
如果都填写.那么会执行两个作用域
>>> x,y=1,2 全局变量
>>> def test_eval():
x,y=3,3 局部变量
n2=eval('x+y',locals(),globals()) 执行最后一个作用域,全局变量
n3=eval('x+y',globals(),locals())
print(n2,n3)
>>> test_eval()
3 6
注:eval()使用原因：
1）在编译语言里要动态地产生代码，基本上是不可能的，但动态语言是可以，意味着软件已经部署到服务器上了，
但只要作很少的更改，只好直接修改这部分的代码，就可立即实现变化，不用整个软件重新加载。
2）在machin learning里根据用户使用这个软件频率，以及方式，可动态地修改代码，适应用户的变化。
娱乐的代码.一行代码写一个可以四则运算的计算器
>>> calc=lambda s: eval(s) 是不是很6
>>> calc('42**2-32//2+4-2')
1750
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值永远为 None
和eval用法一样,实际上gloabls()是一个字典
>>> s='print(x+y)'
>>> exec(s,{'x':1,'y':2})
3
>>> x,y=1,2
>>> exec(s)
3
>>> list(filter(lambda x: x%2 ,range(10))) 奇数
[1, 3, 5, 7, 9] 好像也没有什么好说的
注:给一个作业.请算出三位数的水仙花数,不知道水仙花数的可以百度一下.先不要看代码.自己写一下.看看是不是和作者一样
>>> list(filter(lambda s: (s%10)**3+(s//10%10)**3+(s//100)**3==s,range(100,1000)))
[153, 370, 371, 407]
>>> float() 默认返回0.0
0.0
>>> float(121) 整数转为浮点数
121.0
>>> float(' 3 ') 将字符串转为浮点数.可以有空格.切记复数complex函数是不允许有空格的
3.0
>>> float(' 4 43 43') 不能允许中间有空格,只能是左右可以
Traceback (most recent call last):
File "<pyshell#138>", line 1, in <module>
float(' 4 43 43')
ValueError: could not convert string to float: ' 4 43 43'
支持科学计数法
>>> float('1e-003')
0.001
>>> float('1e3') 是字符串
1000.0
>>> float(1e3) 不是字符串
1000.0
支持无穷大,大小写不敏感
>>> float('inf') 正无穷大
inf
>>> float('-inf') 负无穷大
-inf
>>> float('INf')
inf
支持不是数字处理,大小写不敏感
>>> float('nan') 这个真的是难(nan)啊.
nan
>>> float('NaN')
nan
>>> '{}{}'.format(1,2) 不指定位置.默认按顺序
'12'
>>> '{1}{0}'.format(1,2) 指定位置.按位置填写
'21'
>>> '{name}{age}'.format(age=1,name='作者') 可以指定名字.按键值对的方式填写
'作者1'
可以填写字典
>>> d=dict(name='hello',age=19)
>>> '{name}-{age}'.format(**d) **d叫拆包
'hello-19'
实际上还可以建立索引
>>> ls=['hello',19]
>>> '{0[0]}-{0[1]}'.format(ls) 是不是很强大
'hello-19'
还可以传入类对象
>>> class test_format:
s=1
def test(self):
return 2
>>> '{0.s}'.format(test_format) 如果是第一个的话.0是可以省略的
'1'
>>> '{.s}'.format(test_format) 切记不可去掉 .
'1'
>>> '{0.test()}'.format(test_format()) 但是不能传入对象调用方法
Traceback (most recent call last):
File "<pyshell#183>", line 1, in <module>
'{0.test()}'.format(test_format())
AttributeError: 'test_format' object has no attribute 'test()'
>>> test_format.s 实际上他去执行的代码是这样的
1
>>> '{{0}}-{0}'.format(1) {{}}两个{}叫转义,
'{0}-1'
数字格式化应该是format最有魅力的地方
^, <, > 分别是居中、左对齐、右对齐，后面带宽度，
: 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -
（空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
>>> '{0:0>3d}'.format(1) 0>表示向左填充0, 3表示是否到达3位数或以上,不足填充,d表示十进制
'001'
>>> '{0:0>4x}'.format(24)
'0018'
>>> '{0:0>{1}d}'.format(1,3) 3d实际上还可以把3作为变量给输进去
'001'
>>> '{:*>5}'.format(1)
'****1'
* 1颗五角星
*** 3颗五角星
注:打印一个金字塔 ***** 5颗五角星
n颗五角星 一直类推 ,格式要一直
金字塔代码:
>>> n=8
` >>> for i in range(1,n):
s='{0:^{1}}'.format('*'*(i*2-1),n*2-2)
print(s)`
我们看到frozenset函数立马想起了set函数。他们的区别是前者不可改变，后者是可以修改的
如果你要传数字。关输数字是不行的，他要的参数是可迭代对象。所以
>>> frozenset(1)
Traceback (most recent call last):
File "<pyshell#9>", line 1, in <module>
frozenset(1)
TypeError: 'int' object is not iterable
>>> frozenset((1,)) 你还可以[1],{1}等都行。只要是可以迭代的
frozenset({1})
因为frozenset是不可改变的，所以他可以做成hash值。可以作为字典的key值。
>>> f=frozenset({1,2})
>>> {f:'frozen'}
{frozenset({1, 2}): 'frozen'}
>>> f=set({1,2})
>>> {f:'set'}
Traceback (most recent call last):
File "<pyshell#17>", line 1, in <module>
{f:'set'}
TypeError: unhashable type: 'set
注：这里就不介绍集合的运算，比如差集，并集啊之类。我主要在set函数重点
object -- 对象。
name -- 字符串，对象属性。
default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
>>> class test_getattr:
s=1
>>> getattr(test_getattr,'s') 没有该属性会报错
1
>>> getattr(test_getattr,'s1',2) 没有该属性返回2，第三个参数
2
>>> s='tyoui'
>>> globals() 返回当前全局变量的字典
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>,
'__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 's': 'tyoui'}
>>> globals()['s']
'tyoui'
>>> class test_hasattr:
s=1
>>> hasattr(test_hasattr,'s') 存在
True
>>> hasattr(test_hasattr,'s1') 不存在
False
>>> class test_hasattr:
def test(self):
return 2
>>> hasattr(test_hasattr,'test') 判断方法。第一个的类对象.第二个是方法引用
True
>>> hasattr(test_hasattr,'test()')
False
>>> hash('test')
-8467188814980898581
>>> hash('tyoui')
6170064568863603886
>>> hash(1)
1
注：hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关
hash() 函数的对象字符不管有多长，返回的 hash 值都是固定长度的，一般用在矫正文件一致性。
也可以用于简单加密
实际上这只是一个帮助文档。
>>> help([].append) 比如我想看看列表的增加方法
Help on built-in function append:
append(object, /) method of builtins.list instance
Append object to the end of the list.
>>> hex(10) 正整数没问题
'0xa'
>>> hex(-10) 负整数也没有问题
'-0xa'
>>> hex(12.1) 浮点数就报错了
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
hex(12.1)
TypeError: 'float' object cannot be interpreted as an integer
注：我们这样获得浮点数的十六进制呢？
>>> float.hex(12.3) 利用float.hex(x) 这里的x一点还是浮点数
'0x1.899999999999ap+3'
>>> float.hex(2) 是整数。报错TypeError
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
float.hex(2)
TypeError: descriptor 'hex' requires a 'float' object but received a 'int'
31.id (obj) 获得对象的内存地址id这个函数基本上大家都非常熟悉,我就不多说.但是下面的,你们会解释的清楚吗?
>>> a,b=1,1 为什么a=b=1时,id地址居然是一模一样?
>>> id(a)
140729119466320
>>> id(b)
140729119466320
>>> a,b=257,257 为什么a=b=257时.他们的id地址居然不一样?
>>> id(a)
1896796937264
>>> id(b)
1896796937456
为什么?答案是:Python编译器会自动缓存一些对象.比如数字是从[-5,256]之间,看下面的证明过程
>>> a,b=-5,-5
>>> id(a),id(b) 一样
(140729119466128, 140729119466128)
>>> a,b=-6,-6
>>> id(a),id(b) 不一样
(1896796937488, 1896796937392)
>>> a,b=256,256 一样
>>> id(a),id(b)
(140729119474480, 140729119474480)
>>> a,b=257,257 不一样
>>> id(a),id(b)
(1896796937392, 1896796937488)
>>> input('是不是很简单:')
是不是很简单:是的
'是的'
x是接受字符串或者数字
base是描述x是什么进制(可以是任意进制),默认是十进制,切记.这里base是指的x.而非输出,输出的都是十进制
返回结果都是十进制的整数
第一种情况:如果只有x参数.那么可以是字符串,可以是数字
>>> int(23) 可以是整数
23
>>> int(32.2) 可以是浮点数
32
>>> int('10') 可以是字符串
10
>>> int(1+2j) 但是不能是复数
Traceback (most recent call last):
File "<pyshell#40>", line 1, in <module>
int(1+2j)
TypeError: can't convert complex to int
>>> int(0o123) 可以写进制.切记不能写成字符串形式
83
如果字符串里面包含进制符号.那么一定要指出是几进制.
>>> int('0x123') 字符串里面包含0x符号,那么一定要指出是十六进制,正确的写法是:int('0x123',16)或者int(0x10)
Traceback (most recent call last):
File "<pyshell#45>", line 1, in <module>
int('0x123')
ValueError: invalid literal for int() with base 10: '0x123'
第二种情况:如果base有值,那么x必须填写,并且x只能传输字符串.
>>> int('10',16) 说明字符串里面的是十六进制
16
>>> int('0x123',16) 十六进制转十进制
291
>>> int('231',5) 五进制转十进制,实际上可以是任意进制
66
注:bin函数和这里的oct,int,hex函数有异曲同工之妙,(二进制.八进制.十进制,十六进制),但是他们有稍微不一样的地方,切记
object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。实际上这里我们判断的最多的还是基本类型
实际上他和type()十分相似,不过他们还是有很大的区别
首先返回值类型不一样.其次type()不会认为子类是一种父类类型.不考虑继承关系
当然.那么isinstance就会考虑.
>>> isinstance(2,int) 判断2是是否属于int类型,切记不能粗心大意,写成isinstance(int,2),那么这个意思就是int是否属于2类型?当然会报错的
True
>>> isinstance(2,(list,str,int)) 还可以是一个列表
True
>>> class test_isinstance(list):
pass
>>> isinstance(test_isinstance(),list) 注意,这里传入的是实例对象.而类对象
True
>>> isinstance(test_isinstance,list) 如果是类对象.就会判断失败,
False
>>> type(test_isinstance)
<class 'type'>
>>> type(test_isinstance())
<class '__main__.test_isinstance'>
class -- 类。
classinfo -- 类
issubclass和isinstance的区别是他判断的这是单纯的继承关系,没有属性关系.判断的是两个类之间的关系.
>>> issubclass(2,int) 必须是两个类的对象
Traceback (most recent call last):
File "<pyshell#80>", line 1, in <module>
issubclass(2,int)
TypeError: issubclass() arg 1 must be a class
>>> class test_issubclass(list): 继承list
pass
>>> issubclass(test_issubclass,list) 判断test_issubclass是否list的子类?切记传的是类对象.
True
sentinel -- 参数
如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），
此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
如果被回调函数的返回值等于sentinel，则抛出StopIteration异常，否则返回下一个值.
他返回的是一个迭代对象
第一种情况:参数是第一个的时候,这个很好理解
>>> for i in iter([1,2,3]): 返回一个迭代对象的值
print(i)
1
2
3
第二种情况:如果第二个参数有值代表什么?实际上iter函数会调用实例化对象执行__next__方法.
当__next__返回值等于第二个参数sentinel的值时,停止迭代,否则继续.
>>> class test_iter:
def __init__(self,start):
self.start=start
def get_iter(self):
self.start+=1 累加1,实际上我这里设计的有bug的,因为如果sentinel小于start的话.那么这个就变成无限迭代下去.
不过你可以加一个判断.当迭代到什么值的时候.抛出StopIteration异常
return self.start
>>> t=test_iter(10) 实例化,初始化start=10
>>> [i for i in iter(t.get_iter,14)] 当start==14的时候,停止迭代.切记.14不是要迭代14次.,而且迭代的值等于14就停止.
[11, 12, 13]
>>> len('作者')
2
>>> len([1,2,3])
3
关于list函数.也就是列表,在Python中是至关重要.这里要花大量篇幅来详细讲解
我在上面已经详细的讲解过字典类型.这里和字典类型同样重要的列表类型
创建列表的方式:
>>> ls1=[1,2,3] 第一种用[]括号进行创建,也是最常见的创建方式
>>> ls2=list([1,2,3]) 第二种就是用list函数.传入一个可迭代对象进行创建
>>> ls1,ls2
([1, 2, 3], [1, 2, 3])
创建方式很简单,我们重点来说list里面的方法:最常见的有11个方法.我们一个一个的来讲解
['append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
第一个:append(obj)方法
>>> ls=[1,2,3]
>>> ls.append(4) 传入一个对象.该方法实际上是在末尾增加元素,并且不改变列表对象.
>>> ls
[1, 2, 3, 4]
第二个:clear()方法
>>> ls.clear() 清除列表
>>> ls
[]
第三个:copy()方法
>>> ls=[1,2,3]
>>> copy_ls=ls.copy() 实际上该复制的方式也是浅复制
>>> copy_ls
[1, 2, 3]
请证明一下?证明过程和dict函数证明一样.
>>> ls=[1,2,[1,2]]
>>> copy_ls=ls.copy()
>>> copy_ls[2].append(3)
>>> ls
[1, 2, [1, 2, 3]]
第四个:count(obj)方法
>>> ls
[1, 2, [1, 2, 3]]
>>> ls.count(1)统计列表中的1,切记他不会递归的去统计.实际上他只会统计第一层元素
1
第五个:extend(iterable)方法
>>> ls.extend([2,3]) 合并列表.实际上参数是一个可迭代对象,这种合并列表的速度是最快的,比+要快得多
>>> ls
[1, 2, [1, 2, 3], 2, 3]
第六个:index(obj,start,end)方法
传入一个搜索的对象,从什么范围开始.范围大小是[start,end],默认的开头是0,end=len(ls)
如果搜索到了返回第一个,搜索不到报错
>>> ls.index(2) 搜索到了再第一个元素
1
>>> ls.index(2,2) 从第二个元素开始搜索
3
第七个:insert(index,obj)方法
在第几个位置插入对象,也是增加元素的方法之一.类似于append方法.返回None
>>> ls
[1, 2, [1, 2, 3], 2, 3]
>>> ls.insert(1,4) 在第一的元素位置插入4
>>> ls
[1, 4, 2, [1, 2, 3], 2, 3]
第八个:pop(index)方法
抛出第一几个元素.其中index就是指出抛出元素位置,如果不指出index.那么默认抛出最后一个,如果index大于列表的长度会报错
返回值是抛出元素的值
>>> ls
[1, 4, 2, [1, 2, 3], 2, 3]
>>> ls.pop(1) 抛出位置1的元素
4
>>> ls
[1, 2, [1, 2, 3], 2, 3]
>>> ls.pop() 抛出最后一个
3
>>> ls
[1, 2, [1, 2, 3], 2]
第九个:remove(obj)返回
这个和pop都是抛出的意思.不过pop是按照位置抛出.而remove是按照对象值抛出
移除成功返回值None,如果要移除的值没有在列表会报ValueError错误
>>> ls
[1, 2, [1, 2, 3], 2]
>>> ls.remove(1) 准确点说叫移除元素1,无返回值
>>> ls
[2, [1, 2, 3], 2]
>>> ls.remove(2) 只会移除第一个,然后终止遍历
>>> ls
[[1, 2, 3], 2] 第二个2并没有移除掉
第十个:reverse()方法.该方法叫反转,意思就是把最后个元素和第一个相换,以此类推
都是在同一个列表进行操作.不会生成新的对象
>>> ls
[[1, 2, 3], 2]
>>> ls.reverse() 反转
>>> ls
[2, [1, 2, 3]]
第十一个:sort(key,reverse)方法
对列表进行排序,默认升序,reverse默认是False,如果改成True,就是降序
key -- 主要是用来进行比较的元素，指定可迭代对象中的一个元素来进行排序。
无返回值,None.实际上是对本身进行操作
>>> ls=[2,6,3,0] 切记.这里的列表排序只能针对同一类型
>>> ls.sort() 默认是升序
>>> ls
[0, 2, 3, 6]
进行降序排序
>>> ls=[2,6,3,0]
>>> ls.sort(reverse=True)
>>> ls
[6, 3, 2, 0]
>>> ls=[1,5,'4'] 不同类型会报错
>>> ls.sort()
Traceback (most recent call last):
File "<pyshell#57>", line 1, in <module>
ls.sort()
TypeError: '<' not supported between instances of 'str' and 'int'
思考一个问题,我非要int类型和str类型进行比较?怎么做?
>>> ls=[1,5,'4']
>>> def test_ls_sort(elem):
if isinstance(elem,int): 判断这个元素是int类型
return str(elem) 转为字符串类型进行返回
return elem
>>> ls.sort(key=test_ls_sort) 实际上key就像一个map函数一样,这个在后面要讲,其实就是一种映射关系
>>> ls
[1, '4', 5]
实际上还有一种更加简单的写法.这也是Python独特的魅力所在
>>> ls=[1,5,'4']
>>> ls.sort(key=lambda x: str(x) if isinstance(x,int) else x)
如果是偷懒的话可以这样写:ls.sort(key=lambda x: str(x)) 不建议这样写,简单很好,不过最基本的逻辑还是要保留
>>> ls
[1, '4', 5]
注:最后差一个小知识点:对列表进行操作的其他函数
1、len(list)：列表元素个数
2、max(list)：返回列表元素最大值
3、min(list)：返回列表元素最小值
4、enumerate 用法（打印元素对应的下标）
5、列表切片（list 取值的一种方法）这个就很重要啊
关于切片的使用方法:ls[start:stop:step],从表面意思理解,start是开始.end是结束.step是步长,
>>> ls
[1, '4', 5]
>>> ls[1] 选取位置1
'4'
>>> ls[0:3] 选取位置0到2
[1, '4', 5]
>>> ls[:3] 如果起始位置是0.可以省略不写
[1, '4', 5]
>>> ls[:] 如果结束位置等于列表长度.也是可以省略不写
[1, '4', 5]
>>> ls[::-1] 默认的步长是正数1(从左往右).如果我改写成-1.那么相当于从右往左取
[5, '4', 1]
>>> ls[:100] 如果你的结束位置超过了列表的长度.那么相当于是列表的长度
[1, '4', 5]
>>> ls[100:200] 如果你的起始位置都比列表长.那么返回空列表
[]
并且列表的取值可以负
>>> ls
[1, '4', 5]
>>> ls[:-1] 取负相当于最后一个,类似于:len(ls)-1
[1, '4']
关于更多切片请关注与实现__getitem__魔术方法
证明过程.如下:
>>> class test_slice:
def __getitem__(self,x):
print(x)
>>> t=test_slice()
>>> t[1:3]
slice(1, 3, None) 返回的是切片对象
>>> t[1:4:3]
slice(1, 4, 3)
实际上和globals()函数是不是殊途同归的感觉.不过一个是全局,一个是局部
>>> def test_locals(x):
s=1
print(locals()) 打印局部变量
>>> test_locals(3)
{'x': 3, 's': 1}
我们来增加全部变量看看:
>>> def test_locals(x):
s=1
print(globals()) 打印全局变量
>>> test_locals(3) 实际上打印出来看不到有x和s变量.
{'__name__': '__main__', '__doc__': None, '__package__': None,
'__loader__': <class '_frozen_importlib.BuiltinImporter'>,
'__spec__': None, '__annotations__': {},
'__builtins__': <module 'builtins' (built-in)>,
'test_locals': <function test_locals at 0x00000247A66CFF28>}
function -- 函数
iterable -- 可迭代序列
返回迭代器对象,这个是重要函数
>>> list(map(lambda x:x*2,[1,2,3])) 因为map返回的是map对象.所以要用list转化,
[2, 4, 6]
>>> m=map(lambda x,y:x+y,[1,2,3],[2,3,4]) 多个参数的时候
>>> list(m)
[3, 5, 7]
>>> max(1,2,3,4) 多个参数,都是同一个类型
4
>>> max([1,5,3,5]) 一个列表,或者可迭代对象
5
>>> max('a','b')
'b'
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
obj -- 对象
返回元组列表。
为了给别的代码使用缓冲区里的数据，而不必拷贝，就可以直接使用。
v = memoryview(b'abc123')
print(v[1]) 98
print(v[0]) 97
>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<memory at 0x7f3ddc9f4350>
>>> bytes(v[1:4])
b'bce'
实际上这个和max()的用法一模一样.不过一个是求最大,一个是求最小而已
>>> min(1,2,3)
1
>>> min([1,2,3])
1
其他用法参考max()
iterator -- 可迭代对象
default -- 可选，用于设置在没有下一个元素时返回该默认值，
如果不设置，又没有下一个元素则会触发 StopIteration 异常。
>>> it=iter([1,2,3,4]) 创建一个可以被迭代的对象,参考iter函数
>>> next(it) 只要是可以被迭代的对象,那么这个就可以被执行.
1
>>> next(it)
2
>>> next(it) 但我一直迭代到没有函数值的时候
4
>>> next(it) 报出停止异常
Traceback (most recent call last):
File "<pyshell#7>", line 1, in <module>
next(it)
StopIteration
>>> next(it,'无') 可以设置default参数.
'无'
这个object函数,实际上还真的用的十分之少,唯一用途比较多的就是判断类型的时候
>>> class test_object:
pass
>>> isinstance(test_object,object)
True
这里不像(int)十进制一样.可以传入一个字符串
>>> oct(12) 将十进制转为八进制
'0o14'
>>> oct(0x12) 将十六进制转为八进制
'0o22'
注;这里我提出一个问题.写一个小程序将x进制转为y进制.比如讲5进制转为7进制,12342(5进制)-->???(7进制)
我们这里就利用第三方包
from jtyoui import bs
if __name__ == '__main__':
print(bs.binary_system(1254, 7, 19)) 参数介绍:1235是要转为的数值.7表示是1235是7进制.19表示要转为19进制
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf-8
errors: 报错级别
1）当指明为’strict’时，编码出错则抛出异常ValueError。
2）当指明为’ignore’时，忽略错误。
3）当指明为’replace’时，使用某字符进行替代模式，比如使用’?’来替换出错的。
4）其它相应还有surrogateescape/xmlcharrefreplacs/backslashreplace。
newline: 区分换行符:参数newline是用来控制文本模式之下，一行的结束字符。可以是None，’’，\n，\r，\r\n等。
closefd: 传入的file参数类型
opener:参数opener是用来实现自己定义打开文件方式。
>>> f=open(r'E:/hello.txt','r') 默认的编码与编译器有关,是encoding='cp936',而我的文件是UTF-8的
>>> f
<_io.TextIOWrapper name='E:/hello.txt' mode='r' encoding='cp936'>
>>> f.read() 报错.编码错误
Traceback (most recent call last):
File "<pyshell#2>", line 1, in <module>
f.read()
UnicodeDecodeError: 'gbk' codec can't decode byte 0xac in position 25: illegal multibyte sequence
>>> f=open(r'E:/hello.txt',mode='r',encoding='utf-8') 这样就没有事
>>> f.read()
'hello world\nhi author:本人'
>>> f=open(r'E:/hello.txt',mode='r',encoding='utf-8') 按行读取
>>> f.readlines()
['hello world\n', 'hi author:本人']
>>> f=open(r'E:/hello.txt',mode='r',encoding='utf-8')
>>> f.readline() 读取一行
'hello world\n'
返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)
>>> f.tell()
13
f.seek(偏移量,[起始位置])
用来移动文件指针
偏移量:单位:比特,可正可负
起始位置:0-文件头,默认值;1-当前位置;2-文件尾
seek()的三种模式：
（1）f.seek(p,0) 移动当文件第p个字节处，绝对位置
（2）f.seek(p,1) 移动到相对于当前位置之后的p个字节
（3）f.seek(p,2) 移动到相对文章尾之前的p个字节
>>> f.seek(0,0)
0
>>> f.readlines()
['hello world\n', 'hi author:本人']
>>> f.tell()
29
注意要使用当前位置和结束位置,那么mode的模式必须是字节模式.也就是说必须有个b
>>> f.seek(0)
0
>>> f.readline() 我有两行数据
'hello world\n'
>>> f.seek(3,1) 报错
Traceback (most recent call last):
File "<pyshell#37>", line 1, in <module>
f.seek(3,1)
io.UnsupportedOperation: can't do nonzero cur-relative seeks
注:关于他的写操作,二进制文件操作,请参考mode的设置.更多设置,将在os模块里面详细说明
>>> ord('a') 这个返回的ASCII值
97
>>> ord('作') 这个返回的Unicode值
20316
>>> pow(2,3) 2**3=8
8
>>> pow(2,3,3) 2**3=8%3=2
2
>>> pow(1.1,2.2) 1.1**2.2=1.2332863005546628
1.2332863005546628
如果有第三参数:那么前两个参数都应该是整数
>>> pow(2.1,2,3)
Traceback (most recent call last):
File "<pyshell#10>", line 1, in <module>
pow(2.1,2,3)
TypeError: pow() 3rd argument not allowed unless all arguments are integers
objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep -- 用来间隔多个对象，默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file -- 要写入的文件对象。
这个方法我就没有什么好说的,是用得最多的一个
>>> print('blog','jtyoui','com',sep='.') 最不让人知道的是这个对象间隔符,默认是空格
blog.jtyoui.com
>>> print('blog','jtyoui','com',sep='.',end='.....') 结尾符,默认是换行
blog.jtyoui.com.....
他甚至还可以写入文件:file -- 要写入的文件对象。
fget -- 获取属性值的函数
fset -- 设置属性值的函数
fdel -- 删除属性值函数
doc -- 属性描述信息
定义一个类
>>> class test_property:
def __init__(self,x):
self.__x = x
def getx(self):
return self.__x
def setx(self, value):
self.__x = value
def delx(self):
del self.__x
x = property(getx, setx, delx, "x property")
>>> t=test_property(3) 实例化对象
>>> t.x 实际上调用的是t.getx
3
>>> t.x=4 实际上调用的是t.setx(4)
>>> t.x
4
>>> del t.x 实际上调用的是:t.delx
>>> t.x 没有了,报错
Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>
t.x
File "<pyshell#23>", line 5, in getx
return self._x
AttributeError: 'test_property' object has no attribute '_x'
实际上我们用得更多的是下面这种.
class test_property:
def __init__(self,x):
self.__x = x
@property
def x(self):
"""x property"""
return self.__x
@x.setter
def x(self, value):
self.__x = value
@x.deleter
def x(self):
del self.__x
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 5)没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
>>> list(range(3)) 一个参数,默认是从0开始
[0, 1, 2]
>>> list(range(3,6)) 范围[3,6)
[3, 4, 5]
>>> list(range(3,10,3)) 步长为3
[3, 6, 9]
>>> list(range(3,1,-1)) 如果步长是负数,那么起始位置应该大于结束位置
[3, 2]
>>> s='jtyoui'
>>> repr(s)
"'jtyoui'"
>>> d = {'google': 'google.com'}
>>> repr(d)
"{'google': 'google.com'}"
是不是感觉好像鸡肋一样,其实不是,他其实和str()有点类似.不过str是给人看的,repr是给机器看的.
下面这个等式恒成立
obj==eval(repr(obj))
但是:obj==eval(str(obj)) 就要报错.(除去特殊情况)
请问为什么???
答案是:repr在转化对象的时候加了字符串.而eval在执行字符串的时候,会忽略第一层字符串,相当于字符串里面代码可以被执行一样
如果是str,那么eval就直接去执行字符串里面的代码,这个时候字符串就相当于变量去执行,当然要报错!
>>> obj='有问题吗'
>>> obj==eval(str(obj))
Traceback (most recent call last):
File "<pyshell#58>", line 1, in <module>
obj==eval(str(obj))
File "<string>", line 1, in <module>
NameError: name '有问题吗' is not defined
我说了除去特殊情况,那请问在什么情况下:obj==eval(str(obj))不但不报错,而且还是恒成立????
答案很显然,在有无字符串都不影响的对象下,自然成立,那是不是数值型,对的,如果对象是数值型两个都成立.
>>> obj=1
>>> obj==eval(str(obj)) 整数没问题
True
>>> obj=-12132.2313
>>> obj==eval(str(obj)) 浮点数也没有问题
True
seq -- 要转换的序列，可以是 tuple, string, list 或 range。
切记seq不是可迭代对象,而是序列,比如map也是可迭代对象不过这里就不能用他
>>> list(reversed('jtyoui')) 反转字符串
['i', 'u', 'o', 'y', 't', 'j']
>>> list(reversed([1,2,3])) 列表反转
[3, 2, 1]
x -- 数值型。
n -- 表示保留小数点x位，默认值为 0。
>>> round(6) 整数没问题
6
>>> round(6.233,1) 在保留1位小数点
6.2
>>> round(0.52) 浮点数
1
>>> round(-0.52) 负浮点数
-1
下面是set方法的所有属性,我会一个一个的讲解
['add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection',
'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove',
'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
首先创建set对象
>>> s={1,'a',1.2,object} 一种是用{}进行创建
>>> s
{1, 'a', <class 'object'>, 1.2}
>>> s=set([1,'a',1.2,object]) 另一种是用set函数进行创建
>>> s
{1, 'a', <class 'object'>, 1.2}
>>> s.add(4) 增加元素
>>> s
{1, 'a', 1.2, 4, <class 'object'>}
>>> s.clear() 清除数据
>>> s
set()
copy()复制方法,pop()抛出方法,remove()移除方法,在序列中都是通用的,不在讲解
下面都是关系测试:
>>> x={1,2,3}
>>> y={2,4,6}
差集,意思的除去x中包含y的元素
>>> x.difference(y)
{1, 3}
>>> x-y 和上面一样.意思效果都是一样
{1, 3}
>>> x.difference_update(y) 差集更新,实际上就是把返回的结果更新到x上,类似于: x-=y
>>> x
{1, 3}
>>> x={1,2,3}
>>> x.discard(1) 相当于删除元素,存在1就删除.他和remove不一样的是,discard找不到不报错.而remove要报错的
>>> x
{2, 3}
交集
>>> x={1,2,3}
>>> y={2,3,4}
>>> x.intersection(y) 和:x&y 效果一样.
{2, 3}
intersection_update返回类似于 :x=x.intersection(y) 多了一步赋值操作
>>> x={1,2,3}
>>> y={2,3,4}
>>> x.isdisjoint(y) 判断集合x中没有包含集合y的元素
False 注意,这里是没有包含才是true,包含了false
>>> x={1,2}
>>> y={1,2,3}
>>> x.issubset(y) 判断x是否是y的一部分
True
>>> x.issuperset(y) 判断是x是不是y的父亲,也就是全集
False
>>> x={1,2}
>>> y={1,2}
>>> x.issubset(y) 注意我们知道.当两个集合在一起的时候,也是子集.也是全集
True
>>> x.issuperset(y)
True
>>> x={1,2,3}
>>> y={3,4}
>>> x.union(y) 并集类似于:x|y
{1, 2, 3, 4}
>>> x={1,2,3}
>>> x.update(['a',3,4]) 更新数据.实际上就是多个数据一起添加
>>> x
{1, 2, 3, 4, 'a'}
>>> x={1,2,3}
>>> y={2,3,5}
>>> x.symmetric_difference(y) 返回不要xy中重复的元素
{1, 5}
symmetric_difference_update 实际上就是多了一步赋值操作
注:实际上用+-^&可以做到集合关系,不过不建议这样做.建议使用set里面的方法来调用,有更加的可读性和避免错误
给一个问题,在集合里面大有铭鼎的笛卡尔集怎么生成?
>>> x={1,2,3}
>>> y={4,5,7}
>>> import itertools
>>> list(itertools.product(x,y))
[(1, 4), (1, 5), (1, 7), (2, 4), (2, 5), (2, 7), (3, 4), (3, 5), (3, 7)]
object -- 对象。
name -- 字符串，对象属性。
value -- 属性值。
>>> class test_setattr:
name='jtyoui'
>>> getattr(test_setattr,'name') 复习一下getattr的用法
'jtyoui'
>>> setattr(test_setattr,'age',18) 设置不存在的值,如果存在相当于修改数值
>>> test_setattr.age 调用
18
思考一个问题?我在上面传入的是类对象,而不是类的实例化对象.现在增加了age属性.请问我重新实例化对象调用age会报错吗??
>>> t=test_setattr() 实例化
>>> t.age 没有报错.而且有值?请问为什么?
18
如果我setattr传入的是实例化对象.那么重新实例化类还能调用我新生产的属性吗?
>>> setattr(test_setattr(),'age1',20) 我传入实例化对象
>>> t1=test_setattr() 重新实例化对象
>>> t1.age1 没有这个值?报错了.为什么?
Traceback (most recent call last):
File "<pyshell#80>", line 1, in <module>
t1.age1
AttributeError: 'test_setattr' object has no attribute 'age1'
如果你要是理解了什么是类对象,什么是类的实例化对象,那么这个问题就很好理解,我其实已经在上面的函数中讲述过,
类的实例化对象其实是复制了类对象,每次实例化相当于把类对象作为蓝本进行复制修改.
start -- 起始位置,如果只有一个参数.默认起始位置是0,填写的是结束位置
stop -- 结束位置
step -- 间距
切片都可以用在序列中,实际上对象是去实现了def __getitem__(self, item):魔法函数
>>> ls=[1,2,3,4,5,6]
>>> s=slice(4) 一个参数.默认是[0,4) 4不包括
>>> ls[s]
[1, 2, 3, 4]
>>> s=slice(1,5)
>>> ls[s]
[2, 3, 4, 5]
注:多学一点魔法函数有利于提高效率和减少代码冗余
iterable -- 可迭代对象。
key -- 主要是用来进行比较的元素，只有一个参数，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
实际上,这个函数我们在讲列表的时候已经讲过,sort()和这个一模一样,只不过sort是专门为列表服务,
而sorted是专门为可迭代对象服务
这里就不多说了,可以查看list函数,我直接把list里面的sort方法复制过来,看下面代码
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
>>> ls=[2,6,3,0] 切记.这里的列表排序只能针对同一类型
>>> sorted(ls) 默认是升序
[0, 2, 3, 6]
进行降序排序
>>> sorted(ls,reverse=True)
[6, 3, 2, 0]
class test_staticmethod:
@staticmethod
def f():
print('jtyoui');
test_staticmethod.f() 静态方法无需实例化
test_staticmethod().f() 也可以实例化后调用
该方法不要多说
字符串是所有编程语言里面的一个核心类型,非常重要
['capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format',
'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower',
'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans',
'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines',
'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>> s='abc'
>>> s.capitalize() 首字母大写
'Abc'
>>> s='ABC'
>>> s.casefold() 全部转为小写
'abc'
>>> s.center(6) 居中字符串,默认填充的是空格
' ABC '
>>> s.center(6,'*') 填充*号
'*ABC**'
x.count(str,__start,__end) 指定开始和结束范围来统计某字符串的个数
>>> s='dhadhh'
>>> s.count('h') 统计h字符串的个数,默认是从0位置到结束
3
>>> s.count('h',3,6) 位置从3到6
2
>>> s.count('h',3) 从位置3到结束
2
>>> s.encode('utf-8') 转为UTF-8编码
b'dhadhh'
>>> s
'dhadhh'
>>> s.endswith('h') 以h为结尾?
True
>>> s='I am \t hello'
>>> s.expandtabs() 把\t用空格代替,我暂时还不知道这个有什么用!
'I am hello'
>>> s
'I am \t hello'
>>> s.find('h') 查找字符串的位置
7
>>> s.find('h',8) 这里有两个参数,查找位置的起始和结束,这里和count里面的参数一致
-1 返回-1表示找到失败
>>> '{}'.format('a') 格式化字符串参考上面的format函数
'a'
index返回和find方法一致,不一样的地方是index没有找到不是返回-1.而是直接报错
>>> s='abc123?'
>>> s.isalnum() 不能包含符号字符串
False 包含就是假
>>> s='acv在'
>>> s.isascii() 是否都是ASCII值
False
>>> s='abh12'
>>> s.isalpha() 字符串中可以有大小写，但不可以有数字和符号
False
像这种方法还有很多,比如:isdecimal(),isdigit()
>>> s='abh12'
>>> s.isdigit() 是否全是数字字符串
False
>>> s='21'
>>> s.isdigit()
True
>>> s.isdecimal()
True
>>> s='abc12!'
>>> s.isidentifier() 用于判断字符串是否是有效的 Python 标识符，可用来判断变量名是否合法
False
>>> s='abc12!'
>>> s.islower() 字母全是小写
True
>>> s='一二三四12'
>>> s.isnumeric() 可以包含中文的数字
True
>>> s.isprintable() 是否可以被打印
True
>>> s=' '
>>> s.isspace() 判断字符串是否只有空格
True
>>> s=' 1'
>>> s.isspace()
False
>>> s='i am love'
>>> s.title() 每个单词的首字母都大写
'I Am Love'
>>> s='i am love'
>>> s.istitle() 每个单词的首字母都是大写的吗?
False
>>> s='12!djkaK'
>>> s.isupper() 每个字母都是大写的吗?
False
>>> s='121L'
>>> s.isupper()
True
>>> ':'.join(['a','b']) 字符串拼接
'a:b'
>>> s='abc'
>>> s.ljust(6) 左对齐.和center()方法一样的用法
'abc '
>>> s.ljust(6,'*')
'abc***'
>>> s='ABD'
>>> s.lower() 把每个字母都转为小写字母
'abd'
>>> s='abc'
>>> s.upper() 将每个小写字母转为大写字母
'ABC'
>>> s=' aaashdha'
>>> s.lstrip() 去除左边的空格
'aaashdha'
>>> s='aah'
>>> s.lstrip('a') 去除左边的a字母
'h'
>>> s='abcdfghdb'
>>> s.partition('d') 从左往右第一个进行分段.返回元组的形式
('abc', 'd', 'fghdb')
>>> s.split('d') 从左往右进行分割,一直进行到最后一个
['abc', 'fgh', 'b']
>>> s='abca'
>>> s.replace('a','A') 替换.将a替代为A
'AbcA'
>>> s.replace('a','A',1) 第三个参数是替换的次数,默认是全部替换,1表示替换一次.如果替换次数大于存在个数,默认全部替换
'Abca'
rfind和find功能一样.用法一样.不过一个是从左往右.一个是从右往左
rindex和index一样,方向不同而已
rjust和just一样.都是方向不同而已
rpartition和partition一样,方向不同而已
rsplit和split一样,方向不同而已
rstrip和lstrip一样,方向不同而已
>>> s='i am \n love'
>>> s.splitlines() 换行符分段
['i am ', ' love']
>>> s
'i am \n love'
>>> s.startswith('i') 以什么开头,用法和endswith一样
True
strip相当于lstrip+rstrip
>>> s='A am Love'
>>> s.swapcase() 大写转小写.小写转大写
'a AM lOVE'
>>> s
'A am Love'
>>> s.zfill(10) 左对齐.填充0
'0A am Love'
>>> ''.maketrans('ab','好坏') 相当于第一个参数是key.第二个参数是value,映射成一个字典类型
{97: 22909, 98: 22351}
>>> 'ab'.translate(s) 翻译的过程,相当于把a映射成好.b映射成坏
'好坏'
>>> 'a--b'.translate(s) 是一个映射的过程
'好--坏'
注:字符串的相乘等价于复制
>>> s='abc'
>>> s*3
'abcabcabc'
字符串中的+相当于拼接,但是不推荐使用
>>> s
'abc'
>>> s+s
'abcabc'
iterable -- 可迭代对象，如：列表、元组、集合。
start -- 指定相加的参数，如果没有设置这个值，默认为0。
只要是数值型就可以
>>> sum([1,2,3]) 没有start
6
>>> sum([1,2,3],1) 有start,累加结束之后最后加start
7
>>> sum([1+2j,2+3j],1+1j) 复数都可以
(4+6j)
>>> sum(1,2) 这样是不可以的
Traceback (most recent call last):
File "<pyshell#92>", line 1, in <module>
sum(1,2)
TypeError: 'int' object is not iterable
type -- 类。
object-or-type -- 类，一般是 self
class A:
def __init__(self):
super() 可以直接这样实例化
super(A,self) 这个也是没有问题的
元组的内置方法很少,就两个
'count', 'index'
>>> s=(1,) 如果只有一个元素.切记要加一个逗号
>>> s
(1,)
>>> s=tuple([1,2]) 传入序列
>>> s
(1, 2)
元组一旦创建不可修改增加
>>> s=(1,1,1,2)
>>> s.count(1) 统计1的个数
3
>>> s.index(2) 查找元素2的位置
3
>>> s[3]
2
>>> s[3]=4 不支持修改
Traceback (most recent call last):
File "<pyshell#202>", line 1, in <module>
s[3]=4
TypeError: 'tuple' object does not support item assignment
name -- 类的名称。
bases -- 基类的元组。实际上是继承谁
dict -- 字典，类内定义的命名空间变量。
>>> type(1) 一个参数实际上是返回对象类型
<class 'int'>
>>> type('a')
<class 'str'>
>>> x=type('test_type',(object,),{'t':1}) 这个实际上等价于类
>>> x
<class '__main__.test_type'>
>>> x.t
1
注:type和isinstance的区别在上面就讲过.那有没有觉得type和lambda有异曲同工之妙呢?一个创建方法,一个是类
>>> class test_vars:
s=1
def __init__(self,x):
self.x=x
>>> vars(test_vars) 类对象
mappingproxy({'__module__': '__main__', 's': 1, '__init__': <function test_vars.__init__ at 0x0000023DABEA68C8>,'__doc__': None})
>>> vars(test_vars(2)) 实例化对象
{'x': 2}
>>> vars(test_vars(2))['x']=3 实例化对象的键值对是可以被修改的
>>> vars(test_vars)['s']=3 类对象的键值对是不可以被修改的
Traceback (most recent call last):
File "<pyshell#108>", line 1, in <module>
vars(test_vars)['s']=3
TypeError: 'mappingproxy' object does not support item assignment
注:请思考一个问题.locals()和vars()的区别的????
iterabl -- 一个或多个迭代器;
这样做的目的是效率高节约内存,我经常叫zip为并行迭代器
>>> a=[1,2,3]
>>> b=[2,3,4]
>>> list(zip(a,b))
[(1, 2), (2, 3), (3, 4)]
注:给一个问题,现在有两个列表,一个是装key,一个是装value,现在将key和value组装成键值对(key-value)也就是字典
>>> key=['a','b','c']
>>> value=[1,2,3]
>>> dict(zip(key,value)) 其实我在dict函数已经讲过,不过那个时候不知道zip是干嘛的.现在应该能明白了吧!
{'a': 1, 'b': 2, 'c': 3}
import (name[, globals[, locals[, fromlist[, level]]]]) 函数用于动态加载类和函数 。 import指令做了两件事：1）搜索module，2）绑定到局部变量
内置函数__import__()只做了一件事：搜索module
import指令执行过程中是调用__import__()来完成Module检索的。
搜索module的过程：
在了解搜索的过程前，先来了解一下内部实现中的几个角色：
a）已经搜索过的module会存在于一个module缓存（sys.modules）中。
b）finders | importers: 用于搜索module在哪里，找到后返回的是module-spec
(包含Module在哪里，该用那个loader进行加载等信息)。
其中finders是从build-in 模块中找，importers是从其他位置找。
importers是可扩展的，可以支持文件系统某个路径、zip、urls。
c）loaders: 依据modulespec 进行加载，生成python中的module
module = modulespec.loader.load_module(modulespec.name)
搜索过程如下：
1）如果要搜索的module 的name 在缓存（sys.modules ）中，则进行如下操作：
1.1）如果值是None，抛出 ModuleNotFoundError
1.2）值不是None，直接返回值
2）由finders从内置模块里找，找不到由importer去找，importers也找不到，
module的name到缓存，值为None，然后raise ModuleNotFoundError。
在使用importers去找的时候，如果发现了有.pyc，需要先检查.pyc是否最新。
找到后，返回 生成创建一个module-spec
3）由module-spec中的loader去加载并执行module：
module = modulespec.loader.load_module(modulespec.name)
sys.modules[modulespec.name] = module
modulespec.loader.exec_module(module)
4）最终没有找到，记录module的name到缓存，值为None，然后 raise ModuleNotFoundError
#index.py
def sayHello():
print('hello index')
#mian.py
index = __import__('index')
index.sayHello()
