杂记/进制转换/迭代

abs() 返回数字绝对值

abs(-20)
20

all() 判断给定的元组或列表中所有的元素是否都为True,如果是则返回 True，否则返回False(元素除了是，整数0，空，False外都算是True)

x = [1, 2, 4, “”, “b”]
all(x)
False
x = [1, 2, 4, “b”]
all(x)
True

any() 判断给定的元组或列表是否全为False，是则返回False,有一个为True则返回True
(元素除了是，整数0，空，False外都算是True)

bin() 将一个整数转化为二进制整数，并以字符串的类型返回

bin(25) # 十进制转二进制
‘0b11001’
bin(0x19) # 十六进制转二进制
‘0b11001’
bin(0o31) # 八进制转二进制
‘0b11001’

bool() 将给定参数转换为布尔型，如果没有参数则返回 False
print(bool(0)) #返回False
print(bool(1)) #返回True
print(bool(True)) #返回True
print(bool(False)) #返回False
print(bool(‘’)) #返回False

bytes() 将字符串转换为字节类型
bytes(source, encoding=“ascii/utf-8/…”)
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。

bytes(“字符串”,encoding=‘utf-8’)
b’\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2’
bytes(“hello”,“ascii”)
b’hello’

callable() 判断对象是否可以被调用(是否也是函数)，是可以则返回True，否则返回False

callable(max)
True
x = 123
callable(x)
False

chr() 查看各进制数对应的ASCII码值

print(chr(0b100001))
!
print(chr(0o41))
!
print(chr(0x21))
!
print(chr(33))
!

enumerate() 枚举
enumerate(sequence, start=0) #start=0代表从0开始计，对应下面 (0, ‘x’) 的 0

for i in enumerate(“xyz”):
… print(i, i[0], i[1])
…
(0, ‘x’) 0 x
(1, ‘y’) 1 y
(2, ‘z’) 2 z

x = [“a”, “b”, “c”]
for i in enumerate(x,1):
… print(i, i[0], i[1])
…
(1, ‘a’) 1 a
(2, ‘b’) 2 b
(3, ‘c’) 3 c

a=[“q”,“w”,“e”,“r”]
#创建一个空字典
b=dict()
#这里i表示的是索引，item表示的是它的值
for i,item in enumerate(a):
b[i]=item
print(b) #输出 {0: ‘q’, 1: ‘w’, 2: ‘e’, 3: ‘r’}

filter() 函数是一个对于可迭代对象的过滤器，过滤掉不符合条件的元素，
返回的是一个迭代器，如果要转换为列表，可以使用 list() 来转换

自python2.6开始，新增了一种格式化字符串的函数str.format()，此函数可以快速处理各种字符串。
语法
它通过{}和:来代替%
#通过位置
print (‘{0},{1}’.format(‘chuhao’,20))
#chuhao,20
print (‘{},{}’.format(‘chuhao’,20))
#chuhao,20
print (‘{1},{0},{1}’.format(‘chuhao’,20))
#20,chuhao,20
#通过关键字参数
print (‘{name},{age}’.format(age=18,name=‘chuhao’))
#chuhao,18
class Person:
def init(self,name,age):
self.name = name
self.age = age
def str(self):
return ‘This guy is {self.name},is {self.age} old’.format(self=self)
print (str(Person(‘chuhao’,18))) #This guy is chuhao,is 18 old
#通过映射 list
a_list = [‘chuhao’,20,‘china’]
print (‘my name is {0[0]},from {0[2]},age is {0[1]}’.format(a_list))
#my name is chuhao,from china,age is 20
#通过映射 dict
b_dict = {‘name’:‘chuhao’,‘age’:20,‘province’:‘shanxi’}
print (‘my name is {name}, age is {age},from {province}’.format(**b_dict))
#my name is chuhao, age is 20,from shanxi
#填充与对齐
print (‘{:>8}’.format(‘189’))

189

print (‘{:0>8}’.format(‘189’))
#00000189
print (‘{:a>8}’.format(‘189’))
#aaaaa189
#精度与类型f
#保留两位小数
print (‘{:.2f}’.format(321.33345))
#321.33
#用来做金额的千位分隔符
print (‘{:,}’.format(1234567890))
#1,234,567,890
#其他类型 主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。
print (‘{:b}’.format(18)) #二进制 10010
print (‘{:d}’.format(18)) #十进制 18
print (‘{}’.format(18)) #八进制 22
print (‘{:x}’.format(18)) #十六进制12

globals() 以字典形式返回当前位置的全部的全局变量
locals() 函数会以字典类型返回当前位置的全部局部变量

hex() 将整数转换为十六进制字符串

hex(18) # 十转十六
‘0x12’
hex(0o22) # 八转十六
‘0x12’
hex(0b10010) # 二转十六
‘0x12’

int() 转换为整数（十进制）

int(2.1)
2
int(“0x12”,16)
18
int(“0o22”,8)
18
int(“0b10010”,2)
18
int(“10010”,2)
18
int(“22”,8)
18
int(“12”,16)
18

int(x, base)
#3. base 可取值范围是 2~36，囊括了所有的英文字母(不区分大小写)，

十六进制中F表示15，那么G将在二十进制中表示16，依此类推…Z在三十六进制中表示35

oct() 将整数转换为八进制
print(oct(12)) #输出12的八进制 0o14 十转八
print(oct(0b10010)) #输出0o22 二转八
print(oct(0o1357)) #输出0o1357
print(oct(0x2d9)) #输出0o1331 十六转八

isinstance() 判断对象是否为已知类型
a=2
print(isinstance(a,int)) #返回 True
print(isinstance(a,str)) #返回 Fasle
print(isinstance(a,(str,int,list))) #返回 True 是元组中的一个类型 就行

input() 接受一个标准输入，用户交互

next() 返回迭代器的下个项目

首先获得Iterator对象:

it = iter([1, 2, 3, 4, 5]) # 也可以 iter(‘abcde’)

循环:

while True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration: # 当没有下一个元素的时候会报这个错
# 遇到StopIteration就退出循环
break

pow(x,y) 返回 x的y次方的值

reversed 函数返回一个反转的迭代器
str=‘wasdqwer’
print(list(reversed(str))) #输出 [‘r’, ‘e’, ‘w’, ‘q’, ‘d’, ‘s’, ‘a’, ‘w’]
tuple=(‘r’, ‘e’, ‘w’, ‘q’, ‘d’, ‘s’, ‘a’, ‘w’)
print(list(reversed(tuple))) #输出 [‘w’, ‘a’, ‘s’, ‘d’, ‘q’, ‘w’, ‘e’, ‘r’]

round() 方法返回浮点数x的四舍五入值
round(x, y) #x是浮点数，y代表要保留几位小数点，不接y默认为0