一数据类型相关,bool，int,float,str,list,tuple(元组),set(集合),dict(字典)
bool
print(bool('0'))#True
print(bool('')) #False
print(bool(1)) #True
print(bool([])) #False
print(bool({})) #False
int返回一个基于数字或字符串 x 构造的整数对象
print(int()) #0
print(int(1.2)) #1
print(int("1")) #1
#print(int("1.2")) #ValueError: invalid literal for int() with base
print(int(float("1.2")))#1
float 返回从数字或字符串 x 生成的浮点数
print(float())#0.0
print(float(1))#1.0
print(float(1.2)) #1.2
print(float("1")) #1.0
dict
print(dict(a=1,b=2))#{'a': 1, 'b': 2}
range(start, stop[, step])
虽然被称为函数，但 range 实际上是一个不可变的序列类型
len
返回对象的长度（元素个数）,实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。
二 数据统计相关
abs,min,max,sum,pow(2,3)(求幂),all(所有元素为True),any(至少一个元素为True),round(1.257,2)（保留小数，四舍五入）,len(元素长度)
abs 绝对值,可以是浮点数和数值
print(-1)
print(1)
print(-1.1)
num = -2
print(num.__abs__())
min最小值
print(min(1,2,3)) #1
print(min([1,2,3])) #1
all 所有元素为真
print(all([1,2,0])) #False 元素0
print(all([1,2,{}]))
next
lists = [1,2,4,5]
it = iter(lists)
print(next(it))#1
print(next(it))#2
anext
awaitable anext(async_iterator[, default])3.10 新版功能
其中 async_iterator 是一个异步迭代器。 它接受一个可选参数，当迭代器耗尽时返回。
当进入 await 状态时，从给定异步迭代器（asynchronous iterator）返回下一数据项，迭代完毕则返回 default。
这是内置函数 next() 的异步版本，类似于调用 async_iterator 的 anext() 方法，返回一个 awaitable，等待返回迭代器的下一个值。若有给出 default，则在迭代完毕后会返回给出的值，否则会触发 StopAsyncIteration。
import asyncio
class CustomAsyncIter:
def __init__(self):
self.iterator = iter(['A', 'B'])
def __aiter__(self):
return self
async def __anext__(self):
try:
x = next(self.iterator)
except StopIteration:
raise StopAsyncIteration from None
await asyncio.sleep(1)
return x
async def main1():
iter1 = CustomAsyncIter()
print(await anext(iter1)) # Prints 'A'
print(await anext(iter1)) # Prints 'B'
print(await anext(iter1)) # Raises StopAsyncIteration
async def main2():
iter1 = CustomAsyncIter()
print('Before') # Prints 'Before'
print(await anext(iter1, 'Z')) # Silently terminates the script!!!
print('After') # This never gets executed
asyncio.run(main1())
'''
A
B
raise StopAsyncIteration
'''
asyncio.run(main2())
'''
Before
A
After
'''
文件相关
open
open(file_name [, access_mode][, buffering])
access_mode：决定了打开文件的模式：只读（默认），写入，追加等
不同模式打开文件的完全列表
| 模式 | 描述 |
|---|---|
| t | 文本模式 (默认)。 |
| x | 写模式，新建一个文件，如果该文件已存在则会报错。 |
| b | 二进制模式。 |
| + | 打开一个文件进行更新(可读可写)。 |
| U | 通用换行模式（不推荐）。 |
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
| 模式 | r | r+ | w | w+ | a | a+ |
|---|---|---|---|---|---|---|
| 读 | + | + | + | + | ||
| 写 | + | + | + | + | + | |
| 创建 | + | + | + | + | ||
| 覆盖 | + | + | ||||
| 指针在开始 | + | + | + | + | ||
| 指针在结尾 | + | + |
File对象的属性
以下是和file对象相关的所有属性的列表：
| 属性 | 描述 |
|---|---|
| file.closed | 返回true如果文件已被关闭，否则返回false。 |
| file.mode | 返回被打开文件的访问模式。 |
| file.name | 返回文件的名称。 |
file = open('1.txt','r') #读取
print(file.name,file.closed,file.mode) #1.txt False r
file.close()
File对象的常用方法
| 属性 | 描述 |
|---|---|
| file.close() | 刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入 |
| file.write() | 将任何字符串写入一个打开的文件。（可以是二进制数据） |
| file.read([count]) | 从一个打开的文件中读取一个字符串（非一个字节）。没有count可能会读取到结尾 |
| file.readlines() | 自动将文件内容分析成一个行的列表，该列表可以由 Python 的 for ... in ... 结构进行处理 |
| file.readline() | 只读取一行，比 .readlines() 慢得多(当内内存不够时使用) |
| file.tell() | 文件内的当前位置（下一次的读写会发生在文件开头这么多字节之后），换行符一个字节 |
| file.seek(offset [,from]) | 方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。 |
file = open('1.txt','r') #读取
print('read',file.read(3)) #read 中国
print('tell',file.tell())
file.seek(0,0)
arr = file.readlines()
print('readlines',arr)
file.close()
进制之间的转换
bin(x)
将整数(int)转变为以“0b”前缀的二进制字符串,如果 x 不是 Python 的int对象，它必须定义 __index__() 方法，以便返回整数值
print(bin(2)) #0b10
format(value[, format_spec])
将 value 转换为“格式化后”的形式，格式由 format_spec 进行控制。format_spec 的解释方式取决于 value 参数的类型；但大多数内置类型使用一种标准的格式化语法： 格式规格迷你语言。
print(format(2,'#b'),format(2,'b')) #0b10 10
hex(x)
将整数转换为以“0x”为前缀的小写十六进制字符串。如果 x 不是 Python int对象，则必须定义返回整数的 __index__() 方法。
print(hex(20)) #0x14
oct(x)
将一个整数转变为一个前缀为“0o”的八进制字符串。如果 x 不是 Python int对象，则必须定义返回整数的 __index__() 方法。
print(oct(20)) #0o24
其他
dir() 获取模块里定义的所有模块，变量和函数
import math
print(dir(math))
globals() 和 locals() 函数
根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。
import math
def fun1():
pad = 'ios'
name = '张三'
print('globals',globals())
print('locals',locals())
fun1()
#globals {'__name__': '__main__', '__doc__': "\nprint(bool('0'))#True\nprint(bool('')) #False\nprint(bool(1)) #True\nprint(bool([])) #False\nprint(bool({})) #False\n", '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000266876C1A90>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/python/test/function/system.py', '__cached__': None, 'math': <module 'math' (built-in)>, 'fun1': <function fun1 at 0x0000026687B97820>}
#locals {'pad': 'ios', 'name': '张三'}
divmod(a, b)
以两个（非复数）数字为参数，在作整数除法时，返回商和余数。若操作数为混合类型，则适用二进制算术运算符的规则。对于整数而言，结果与 (a // b, a % b) 相同。对于浮点数则结果为(q, a % b)，其中 q 通常为 math.floor(a / b)，但可能比它小 1。在任何情况下，q * b + a % b 都非常接近 a，如果 a % b 非零，则结果符号与 b 相同，并且 0 <= abs(a % b) < abs(b)。
print(divmod(2,3),divmod(8,3)) #(0, 2) (2, 2)
enumerate(iterable, start=0)
返回一个枚举对象。iterable 必须是一个序列，或其他支持迭代的对象。返回的迭代器的 __next__()方法返回一个元组，里面包含一个计数值（从 start 开始，默认为 0）和通过迭代 iterable 获得的值。
print(list(enumerate(['Spring', 'Summer', 'Fall', 'Winter'])))#[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
print(list(enumerate(['Spring', 'Summer', 'Fall', 'Winter'],2))) #[(2, 'Spring'), (3, 'Summer'), (4, 'Fall'), (5, 'Winter')]
eval(expression[, globals[, locals]])
实参是一个字符串，以及可选的 globals 和 locals。globals 实参必须是一个字典。locals 可以是任何映射对象。也可以执行一段代码
x= 1
print(eval('x+1'))#2
print(eval('round(1.34*2)+1'))#2
exec(object[, globals[, locals]])
这个函数支持动态执行 Python 代码。 object 必须是字符串或者代码对象。 如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）。如果是代码对象，它将被直接执行。 在任何情况下，被执行的代码都应当是有效的文件输入（见参考手册中的 文件输入 一节）。 请注意即使在传递给 exec()函数的代码的上下文中，nonlocal, yield 和 return 语句也不能在函数定义以外使用。 该函数的返回值是 None。
exec('print("Hello World")')#Hello World
exec("""for i in range(5):
print ("iter time: %d" % i)
""")
#iter time: 0
#iter time: 1
#iter time: 2
#iter time: 3
#iter time: 4
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
y = 20
exec(expr)
exec(expr, {'x': 1, 'y': 2})
exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
func()
#60
#33
#34
filter(function, iterable)
用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
def is_odd(n):
return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(list(newlist)) #[1, 3, 5, 7, 9]
iter(object[, sentinel])
用来生成迭代器。object -- 支持迭代的集合对象,sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的next()方法时，都会调用 object。
getattr(object, name[, default])
返回对象命名属性的值。name 必须是字符串。如果该字符串是对象的属性之一，则返回该属性的值,例如， getattr(x, 'foobar') 等同于 x.foobar。如果指定的属性不存在，且提供了 default 值，则返回它，否则触发AttributeError
import math
print(getattr(math,'__name__')) #math
hasattr(object, name)
该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回 True，否则返回 False。
import math
print(hasattr(math,'__name__')) #True
hash(object)
返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值
help('sys') # 查看 sys 模块的帮助
……显示帮助信息……
id(object)
返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的id() 值。
x= 1
print(id(x)) #1374411751664
type(name, bases, dict)
如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
- name -- 类的名称。
- bases -- 基类的元组。
- dict -- 字典，类内定义的命名空间变量。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
print(type(1) ) #<type 'int'>
input([prompt])
如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。
s = input('--> ')
print(s)
map(function, iterable, ...)
会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的迭代器。
def fun1(num):
return num**2
print(list(map(fun1,[1,2,3,4,5])))
reversed(seq)
用于反向列表中元素。该方法没有返回值，但是会对列表的元素进行反向排序。
aList = [123, 'xyz', 'zara', 'abc', 'xyz']
aList.reverse()
print("List : ", aList)#List : ['xyz', 'abc', 'zara', 'xyz', 123]
slice(start, stop[, step])
实现切片对象，主要用在切片操作函数里的参数传递。
slice1 = slice(1,8,2)
print(slice1)
arr = range(10)
print(list(arr[slice1])) #range(1, 8, 2)
sorted(iterable, cmp=None, key=None, reverse=False)
- iterable -- 可迭代对象。
- cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
- key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
a = [5,7,6,3,4,1,2]
b= sorted(a)
print(a)
print(b)
super(type[, object-or-type])
用于调用父类(超类)的一个方法。
是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
class A:
def add(self, x):
y = x + 1
print(y)
class B(A):
def add(self, x):
super().add(x)
b = B()
b.add(2)
vars([object])
返回对象object的属性和属性值的字典对象。
返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。
import math
print(vars(math))
zip([iterable, ...])
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
a = [1,2,3]
b = [4,5,6]
print(zip(a,b)) #<zip object at 0x0000020FD335B480>
print(list(zip(a,b))) #[(1, 4), (2, 5), (3, 6)]
print(dict(zip(a,b))) #{1: 4, 2: 5, 3: 6}
网友评论