python自动化学习笔记（day9）——内置函数

最新推荐文章于 2022-07-12 07:29:02 发布

Lionel_luo

最新推荐文章于 2022-07-12 07:29:02 发布

阅读量1.1k

点赞数

文章标签： python 自动化开发语言

本文链接：https://blog.youkuaiyun.com/weixin_58716099/article/details/121351042

版权

一、基本数据类型类

1.1 int

class int(x,base=10)

返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0。对于浮点数，它将向零舍入。

如果 x 不是数字，或者有 base 参数，x 必须是字符串、bytes、表示进制为 base 的整数字面值的 bytearray 实例。该文字前可以有 + 或 - （中间不能有空格），前后可以有空格。一个进制为 n 的数字包含 0 到 n-1 的数，其中 a 到 z （或 A 到 Z ）表示 10 到 35。

@@（简单来说）：将一个数字或字符串转换成整数。如果 x 不是一个数字，那么它必须是和 base 匹配的整数字符串表达式

a = int(10)
print(a)

b = int('10')
print(b)

c = int(-10)
print(c)

-10

d = int('10',2) #可以传入base参数，选择进制
print(d)

1.2 float

class float([x])

返回从数字或字符串 x 生成的浮点数。

如果参数是个字符串，则应包含一个十进制数字，前面可选带上符号，也可选前后带有空白符。符号可以是+ 或 -；+ 符号对值没有影响。

@@：将一个字符串或数字转换为浮点数

a = float(4)
print(a)

4.0

b = float('1.4')
print(b)

1.4

c = float('-2.4')
print(c)

-2.4

1.3 complex

class complex([real[, imag]])

返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。第二个形参不能是字符串。每个实参都可以是任意的数值类型（包括复数）。如果省略了 imag，则默认值为零，构造函数会像 int 和 float 一样进行数值转换。如果两个实参都省略，则返回 0j。

@@：创建一个复数通过实部和虚部

a = complex(10)
print(a)

(10+0j)

b = complex(4,4) #第一个参数不为字符串时，可以指定imag的值
print(b)

(4+4j)

c = complex('4',4) #第一个参数为字符串时，传入imag会报错
print(c)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

~\AppData\Local\Temp/ipykernel_11384/2079666097.py in <module>
----> 1 c = complex('4',4)
      2 print(c)

TypeError: complex() can't take second arg if first is a string

1.4 str

class str(object=b'', encoding='utf-8', errors='strict')

返回 object 的字符串版本。如果未提供 object 则返回空字符串。在其他情况下 str() 的行为取决于 encoding 或 errors 是否有给出

@@：通过给定的对象创建一个新的字符串对象。

a = str(123)
print(a)

b = str('abc')
print(b)

abc

1.5 list

class list([iterable])

虽然被称为函数，list 实际上是一种可变序列类型

可以用多种方式构建列表：

@@：根据传入的可迭代对象创建一个列表，如果没有参数返回空列表

 使用一对方括号来表示空列表: []

 使用方括号，其中的项以逗号分隔: [a], [a, b, c]

 使用列表推导式: [x for x in iterable]

 使用类型的构造器: list() 或 list(iterable)

a = list()
print(a)

[]

b = list([1,2,3])
print(b)

[1, 2, 3]

1.6 tuple

class tuple([iterable])

虽然被称为函数，但 tuple 实际上是一个不可变的序列类型

可以用多种方式构建元组：

@@：根据传入的可迭代对象创建一个元组，如果没有参数返回空元组

使用一对圆括号来表示空元组: ()

使用一个后缀的逗号来表示单元组: a, 或 (a,)

使用以逗号分隔的多个项: a, b, c or (a, b, c)

使用内置的 tuple(): tuple() 或 tuple(iterable)

a = tuple()
print(a)

()

b = tuple([1,2,3])
print(b)

(1, 2, 3)

1.7 set

class set([iterable])

返回一个新的 set 对象，可以选择带有从 iterable 获取的元素。元素必须是可哈希的对象

@@：根据传入的可迭代对象创建一个集合对象。

a = set()
print(a)

set()

b = set([1,2,3])
print(b)

{1, 2, 3}

c = set([1,[1,2]]) # 元素为不可哈希对象会报错
print(c)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

~\AppData\Local\Temp/ipykernel_11384/935474414.py in <module>
----> 1 c = set([1,[1,2]])
      2 print(c)

TypeError: unhashable type: 'list'

1.8 dict

class dict(iterable, **kwarg)

创建一个新的字典。dict 对象是一个字典类。

字典可用多种方式来创建:

@@：根据传入的参数创建一个字典对象

使用花括号内以逗号分隔 键: 值 对的方式: {'jack': 4098, 'sjoerd': 4127} or {4098: 'jack', 4127: 'sjoerd'}

使用字典推导式: {}, {x: x ** 2 for x in range(10)}

使用类型构造器: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)

a = dict()
print(a)

{}

b = dict({'a':1, 'b':2})
print(b)

{'a': 1, 'b': 2}

c = dict([('a',1), ('b',2)])
print(c)

{'a': 1, 'b': 2}

二、常用内建函数

2.1 print

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

将 objects 打印输出至 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep 、 end 、 file 和 flush 必须以关键字参数的形式给出。

所有非关键字参数都会被转换为字符串，就像是执行了 str() 一样，并会被写入到流，以 sep 且在末尾加上 end。 sep 和 end 都必须为字符串；它们也可以为 None，这意味着使用默认值。如果没有给出 objects，则 print() 将只写入 end。

@@：打印传入对象的文本流

print()

print(1)

print(1,2,3,sep = '-', end = '\t')

1-2-3

2.2 input

input([prompt])

如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发 EOFError

@@：接收用户的输入数据，以字符串的形式返回。可以接收字符串参数最为提示信息输出

a = input('---->')

----> 123

'123'

2.3 type

class type(name, bases, dict, **kwds)

传入一个参数时，返回 object 的类型。返回值是一个 type 对象，通常与 object.class 所返回的对象相同。

传入三个参数时，返回一个新的 type 对象。这在本质上是 class 语句的一种动态形式，name 字符串即类名并会成为 name 属性；bases 元组包含基类并会成为 bases 属性；如果为空则会添加所有类的终极基类 object。 dict 字典包含类主体的属性和方法定义；它在成为 dict 属性之前可能会被拷贝或包装。下面两条语句会创建相同的 type 对象:

@@：返回参数的类型

a = 1
b = type(a)
b

int

class A:
    pass

b = type(A)
b

type

2.4 dir

dir([object])

如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。

默认的 dir() 机制对不同类型的对象行为不同，它会试图返回最相关而不是最全的信息：

@@：返回传入对象的所有属性和方法名的列表

如果对象是模块对象，则列表包含模块的属性名称。

如果对象是类型或类对象，则列表包含它们的属性名称，并且递归查找所有基类的属性。

否则，列表包含对象的属性名称，它的类属性名称，并且递归查找它的类的所有基类的属性。

dir()

['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']

dir(int)

['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

class A:
    def __dir__(self):
        return[1,2,3]
b = A()
dir(b)

[1, 2, 3]

因为 dir() 主要是为了便于在交互式时使用，所以它会试图返回人们感兴趣的名字集合，而不是试图保证结果的严格性或一致性，它具体的行为也可能在不同版本之间改变。例如，当实参是一个类时，metaclass 的属性不包含在结果列表中。

2.5 help

help([object])

启动内置的帮助系统（此函数主要在交互式中使用）。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。

@@：返回内建对象的帮助信息

help()

Welcome to Python 3.9's help utility!

If this is your first time using Python, you should definitely check out
the tutorial on the Internet at https://docs.python.org/3.9/tutorial/.

Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules.  To quit this help utility and
return to the interpreter, just type "quit".

To get a list of available modules, keywords, symbols, or topics, type
"modules", "keywords", "symbols", or "topics".  Each module also comes
with a one-line summary of what it does; to list the modules whose name
or summary contain a given string such as "spam", type "modules spam".

help>  print

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

help(print)

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

2.6 len

len(s)

返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。

@@：返回容器的元素个数

a = [1,2,3,4]
len(a)

b = range(1,10)
len(b)

2.7 hash

hash(object)

返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。

@@：返回对象的 hash 值

hash(1)

hash('abc')

8352503870284988943

hash([1,2]) # 不可哈希对象会报错

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

~\AppData\Local\Temp/ipykernel_11384/2961728412.py in <module>
----> 1 hash([1,2])

TypeError: unhashable type: 'list'

2.8 iter

iter(object[, sentinel])

返回一个 iterator 对象。根据是否存在第二个实参，第一个实参的解释是非常不同的。如果没有第二个实参，object 必须是支持迭代协议（有 iter() 方法）的集合对象，或必须支持序列协议（有 getitem() 方法，且数字参数从 0 开始）。如果它不支持这些协议，会触发 TypeError。如果有第二个实参 sentinel，那么 object 必须是可调用的对象。这种情况下生成的迭代器，每次迭代调用它的 next() 方法时都会不带实参地调用 object；如果返回的结果是 sentinel 则触发 StopIteration，否则返回调用结果。

@@：根据传入的可迭代对象返回一个迭代器

print(iter([1,2]))

<list_iterator object at 0x0000017857823B50>

iter(1) #传入一个不可迭代的元素，会报错

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

~\AppData\Local\Temp/ipykernel_11384/1608224504.py in <module>
----> 1 iter(1) #传入一个不可迭代的元素，会报错

TypeError: 'int' object is not iterable

2.9 id

id(object)

返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值。

@@：返回传入对象的身份 id（虚拟内存地址的整数形式）

a = 1
id(a)

1616259344688

b = 1 
id(b)

1616259344688

c = [1,2,3]
id(c)

1616372960768

2.10 range

class range(start, stop[, step])

虽然被称为函数，但 range 实际上是一个不可变的序列类型

range 构造器的参数必须为整数（可以是内置的 int 或任何实现了 index 特殊方法的对象）。如果省略 step 参数，其默认值为 1。如果省略 start 参数，其默认值为 0，如果 step 为零则会引发 ValueError。

如果 step 为正值，确定 range r 内容的公式为 r[i] = start + step*i 其中 i >= 0 且 r[i] < stop。

如果 step 为负值，确定 range 内容的公式仍然为 r[i] = start + step*i，但限制条件改为 i >= 0 且 r[i] > stop.

@@：返回一个 range object 对象，产生整数序列

range(10)

range(0, 10)

list(range(10))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list(range(0, 9, 3))

[0, 3, 6]

list(range(0, -10, -1))

[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]